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 #include <sys/sysctl.h>
  56 #else
  57 #include <util.h>
  58 #endif
  59 #else
  60 #ifdef __linux__
  61 #include <pty.h>
  62 #include <malloc.h>
  63 #include <sys/prctl.h>
  64
  65 #include <linux/ppdev.h>
  66 #include <linux/parport.h>
  67 #endif
  68 #ifdef __sun__
  69 #include <sys/stat.h>
  70 #include <sys/ethernet.h>
  71 #include <sys/sockio.h>
  72 #include <netinet/arp.h>
  73 #include <netinet/in.h>
  74 #include <netinet/in_systm.h>
  75 #include <netinet/ip.h>
  76 #include <netinet/ip_icmp.h> // must come after ip.h
  77 #include <netinet/udp.h>
  78 #include <netinet/tcp.h>
  79 #include <net/if.h>
  80 #include <syslog.h>
  81 #include <stropts.h>
  82 /* See MySQL bug #7156 (http://bugs.mysql.com/bug.php?id=7156) for
  83    discussion about Solaris header problems */
  84 extern int madvise(caddr_t, size_t, int);
  85 #endif
  86 #endif
  87 #endif
  88
  89 #if defined(__OpenBSD__)
  90 #include <util.h>
  91 #endif
  92
  93 #if defined(CONFIG_VDE)
  94 #include <libvdeplug.h>
  95 #endif
  96
  97 #ifdef _WIN32
  98 #include <windows.h>
  99 #endif
 100
 101 #ifdef CONFIG_SDL
 102 #if defined(__APPLE__) || defined(main)
 103 #include <SDL.h>
 104 int qemu_main(int argc, char **argv, char **envp);
 105 int main(int argc, char **argv)
 106 {
 107     return qemu_main(argc, argv, NULL);
 108 }
 109 #undef main
 110 #define main qemu_main
 111 #endif
 112 #endif /* CONFIG_SDL */
 113
 114 #ifdef CONFIG_COCOA
 115 #undef main
 116 #define main qemu_main
 117 #endif /* CONFIG_COCOA */
 118
 119 #include "hw/hw.h"
 120 #include "hw/boards.h"
 121 #include "hw/usb.h"
 122 #include "hw/pcmcia.h"
 123 #include "hw/pc.h"
 124 #include "hw/isa.h"
 125 #include "hw/baum.h"
 126 #include "hw/bt.h"
 127 #include "hw/watchdog.h"
 128 #include "hw/smbios.h"
 129 #include "hw/xen.h"
 130 #include "hw/qdev.h"
 131 #include "hw/loader.h"
 132 #include "bt-host.h"
 133 #include "net.h"
 134 #include "net/slirp.h"
 135 #include "monitor.h"
 136 #include "console.h"
 137 #include "sysemu.h"
 138 #include "gdbstub.h"
 139 #include "qemu-timer.h"
 140 #include "qemu-char.h"
 141 #include "cache-utils.h"
 142 #include "block.h"
 143 #include "block_int.h"
 144 #include "block-migration.h"
 145 #include "dma.h"
 146 #include "audio/audio.h"
 147 #include "migration.h"
 148 #include "kvm.h"
 149 #include "qemu-option.h"
 150 #include "qemu-config.h"
 151 #include "qemu-objects.h"
 152 #ifdef CONFIG_LINUX
 153 #include "fsdev/qemu-fsdev.h"
 154 #endif
 155
 156 #include "disas.h"
 157
 158 #include "qemu_socket.h"
 159
 160 #include "slirp/libslirp.h"
 161
 162 #include "qemu-queue.h"
 163 #include "cpus.h"
 164 #include "arch_init.h"
 165
 166 //#define DEBUG_NET
 167 //#define DEBUG_SLIRP
 168
 169 #define DEFAULT_RAM_SIZE 128
 170
 171 #define MAX_VIRTIO_CONSOLES 1
 172
 173 static const char *data_dir;
 174 const char *bios_name = NULL;
 175 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
 176    to store the VM snapshots */
 177 struct drivelist drives = QTAILQ_HEAD_INITIALIZER(drives);
 178 struct driveoptlist driveopts = QTAILQ_HEAD_INITIALIZER(driveopts);
 179 enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
 180 DisplayType display_type = DT_DEFAULT;
 181 const char* keyboard_layout = NULL;
 182 ram_addr_t ram_size;
 183 const char *mem_path = NULL;
 184 #ifdef MAP_POPULATE
 185 int mem_prealloc = 0; /* force preallocation of physical target memory */
 186 #endif
 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 static int full_screen = 0;
 196 #ifdef CONFIG_SDL
 197 static int no_frame = 0;
 198 #endif
 199 int no_quit = 0;
 200 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
 201 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
 202 CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
 203 int win2k_install_hack = 0;
 204 int rtc_td_hack = 0;
 205 int usb_enabled = 0;
 206 int singlestep = 0;
 207 int smp_cpus = 1;
 208 int max_cpus = 0;
 209 int smp_cores = 1;
 210 int smp_threads = 1;
 211 const char *vnc_display;
 212 int acpi_enabled = 1;
 213 int no_hpet = 0;
 214 int fd_bootchk = 1;
 215 int no_reboot = 0;
 216 int no_shutdown = 0;
 217 int cursor_hide = 1;
 218 int graphic_rotate = 0;
 219 uint8_t irq0override = 1;
 220 #ifndef _WIN32
 221 int daemonize = 0;
 222 #endif
 223 const char *watchdog;
 224 const char *option_rom[MAX_OPTION_ROMS];
 225 int nb_option_roms;
 226 int semihosting_enabled = 0;
 227 int old_param = 0;
 228 const char *qemu_name;
 229 int alt_grab = 0;
 230 int ctrl_grab = 0;
 231 unsigned int nb_prom_envs = 0;
 232 const char *prom_envs[MAX_PROM_ENVS];
 233 int boot_menu;
 234
 235 int nb_numa_nodes;
 236 uint64_t node_mem[MAX_NODES];
 237 uint64_t node_cpumask[MAX_NODES];
 238
 239 static QEMUTimer *nographic_timer;
 240
 241 uint8_t qemu_uuid[16];
 242
 243 static QEMUBootSetHandler *boot_set_handler;
 244 static void *boot_set_opaque;
 245
 246 int kvm_allowed = 0;
 247 uint32_t xen_domid;
 248 enum xen_mode xen_mode = XEN_EMULATE;
 249
 250 static int default_serial = 1;
 251 static int default_parallel = 1;
 252 static int default_virtcon = 1;
 253 static int default_monitor = 1;
 254 static int default_vga = 1;
 255 static int default_floppy = 1;
 256 static int default_cdrom = 1;
 257 static int default_sdcard = 1;
 258
 259 static struct {
 260     const char *driver;
 261     int *flag;
 262 } default_list[] = {
 263     { .driver = "isa-serial",           .flag = &default_serial    },
 264     { .driver = "isa-parallel",         .flag = &default_parallel  },
 265     { .driver = "isa-fdc",              .flag = &default_floppy    },
 266     { .driver = "ide-drive",            .flag = &default_cdrom     },
 267     { .driver = "virtio-serial-pci",    .flag = &default_virtcon   },
 268     { .driver = "virtio-serial-s390",   .flag = &default_virtcon   },
 269     { .driver = "virtio-serial",        .flag = &default_virtcon   },
 270     { .driver = "VGA",                  .flag = &default_vga       },
 271     { .driver = "cirrus-vga",           .flag = &default_vga       },
 272     { .driver = "vmware-svga",          .flag = &default_vga       },
 273 };
 274
 275 static int default_driver_check(QemuOpts *opts, void *opaque)
 276 {
 277     const char *driver = qemu_opt_get(opts, "driver");
 278     int i;
 279
 280     if (!driver)
 281         return 0;
 282     for (i = 0; i < ARRAY_SIZE(default_list); i++) {
 283         if (strcmp(default_list[i].driver, driver) != 0)
 284             continue;
 285         *(default_list[i].flag) = 0;
 286     }
 287     return 0;
 288 }
 289
 290 /***********************************************************/
 291
 292 static void set_proc_name(const char *s)
 293 {
 294 #if defined(__linux__) && defined(PR_SET_NAME)
 295     char name[16];
 296     if (!s)
 297         return;
 298     name[sizeof(name) - 1] = 0;
 299     strncpy(name, s, sizeof(name));
 300     /* Could rewrite argv[0] too, but that's a bit more complicated.
 301        This simple way is enough for `top'. */
 302     prctl(PR_SET_NAME, name);
 303 #endif
 304 }
 305
 306 /***********************************************************/
 307 /* real time host monotonic timer */
 308
 309 /* compute with 96 bit intermediate result: (a*b)/c */
 310 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
 311 {
 312     union {
 313         uint64_t ll;
 314         struct {
 315 #ifdef HOST_WORDS_BIGENDIAN
 316             uint32_t high, low;
 317 #else
 318             uint32_t low, high;
 319 #endif
 320         } l;
 321     } u, res;
 322     uint64_t rl, rh;
 323
 324     u.ll = a;
 325     rl = (uint64_t)u.l.low * (uint64_t)b;
 326     rh = (uint64_t)u.l.high * (uint64_t)b;
 327     rh += (rl >> 32);
 328     res.l.high = rh / c;
 329     res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
 330     return res.ll;
 331 }
 332
 333 /***********************************************************/
 334 /* host time/date access */
 335 void qemu_get_timedate(struct tm *tm, int offset)
 336 {
 337     time_t ti;
 338     struct tm *ret;
 339
 340     time(&ti);
 341     ti += offset;
 342     if (rtc_date_offset == -1) {
 343         if (rtc_utc)
 344             ret = gmtime(&ti);
 345         else
 346             ret = localtime(&ti);
 347     } else {
 348         ti -= rtc_date_offset;
 349         ret = gmtime(&ti);
 350     }
 351
 352     memcpy(tm, ret, sizeof(struct tm));
 353 }
 354
 355 int qemu_timedate_diff(struct tm *tm)
 356 {
 357     time_t seconds;
 358
 359     if (rtc_date_offset == -1)
 360         if (rtc_utc)
 361             seconds = mktimegm(tm);
 362         else
 363             seconds = mktime(tm);
 364     else
 365         seconds = mktimegm(tm) + rtc_date_offset;
 366
 367     return seconds - time(NULL);
 368 }
 369
 370 void rtc_change_mon_event(struct tm *tm)
 371 {
 372     QObject *data;
 373
 374     data = qobject_from_jsonf("{ 'offset': %d }", qemu_timedate_diff(tm));
 375     monitor_protocol_event(QEVENT_RTC_CHANGE, data);
 376     qobject_decref(data);
 377 }
 378
 379 static void configure_rtc_date_offset(const char *startdate, int legacy)
 380 {
 381     time_t rtc_start_date;
 382     struct tm tm;
 383
 384     if (!strcmp(startdate, "now") && legacy) {
 385         rtc_date_offset = -1;
 386     } else {
 387         if (sscanf(startdate, "%d-%d-%dT%d:%d:%d",
 388                    &tm.tm_year,
 389                    &tm.tm_mon,
 390                    &tm.tm_mday,
 391                    &tm.tm_hour,
 392                    &tm.tm_min,
 393                    &tm.tm_sec) == 6) {
 394             /* OK */
 395         } else if (sscanf(startdate, "%d-%d-%d",
 396                           &tm.tm_year,
 397                           &tm.tm_mon,
 398                           &tm.tm_mday) == 3) {
 399             tm.tm_hour = 0;
 400             tm.tm_min = 0;
 401             tm.tm_sec = 0;
 402         } else {
 403             goto date_fail;
 404         }
 405         tm.tm_year -= 1900;
 406         tm.tm_mon--;
 407         rtc_start_date = mktimegm(&tm);
 408         if (rtc_start_date == -1) {
 409         date_fail:
 410             fprintf(stderr, "Invalid date format. Valid formats are:\n"
 411                             "'2006-06-17T16:01:21' or '2006-06-17'\n");
 412             exit(1);
 413         }
 414         rtc_date_offset = time(NULL) - rtc_start_date;
 415     }
 416 }
 417
 418 static void configure_rtc(QemuOpts *opts)
 419 {
 420     const char *value;
 421
 422     value = qemu_opt_get(opts, "base");
 423     if (value) {
 424         if (!strcmp(value, "utc")) {
 425             rtc_utc = 1;
 426         } else if (!strcmp(value, "localtime")) {
 427             rtc_utc = 0;
 428         } else {
 429             configure_rtc_date_offset(value, 0);
 430         }
 431     }
 432     value = qemu_opt_get(opts, "clock");
 433     if (value) {
 434         if (!strcmp(value, "host")) {
 435             rtc_clock = host_clock;
 436         } else if (!strcmp(value, "vm")) {
 437             rtc_clock = vm_clock;
 438         } else {
 439             fprintf(stderr, "qemu: invalid option value '%s'\n", value);
 440             exit(1);
 441         }
 442     }
 443     value = qemu_opt_get(opts, "driftfix");
 444     if (value) {
 445         if (!strcmp(value, "slew")) {
 446             rtc_td_hack = 1;
 447         } else if (!strcmp(value, "none")) {
 448             rtc_td_hack = 0;
 449         } else {
 450             fprintf(stderr, "qemu: invalid option value '%s'\n", value);
 451             exit(1);
 452         }
 453     }
 454 }
 455
 456 /***********************************************************/
 457 /* Bluetooth support */
 458 static int nb_hcis;
 459 static int cur_hci;
 460 static struct HCIInfo *hci_table[MAX_NICS];
 461
 462 static struct bt_vlan_s {
 463     struct bt_scatternet_s net;
 464     int id;
 465     struct bt_vlan_s *next;
 466 } *first_bt_vlan;
 467
 468 /* find or alloc a new bluetooth "VLAN" */
 469 static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
 470 {
 471     struct bt_vlan_s **pvlan, *vlan;
 472     for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
 473         if (vlan->id == id)
 474             return &vlan->net;
 475     }
 476     vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
 477     vlan->id = id;
 478     pvlan = &first_bt_vlan;
 479     while (*pvlan != NULL)
 480         pvlan = &(*pvlan)->next;
 481     *pvlan = vlan;
 482     return &vlan->net;
 483 }
 484
 485 static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
 486 {
 487 }
 488
 489 static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
 490 {
 491     return -ENOTSUP;
 492 }
 493
 494 static struct HCIInfo null_hci = {
 495     .cmd_send = null_hci_send,
 496     .sco_send = null_hci_send,
 497     .acl_send = null_hci_send,
 498     .bdaddr_set = null_hci_addr_set,
 499 };
 500
 501 struct HCIInfo *qemu_next_hci(void)
 502 {
 503     if (cur_hci == nb_hcis)
 504         return &null_hci;
 505
 506     return hci_table[cur_hci++];
 507 }
 508
 509 static struct HCIInfo *hci_init(const char *str)
 510 {
 511     char *endp;
 512     struct bt_scatternet_s *vlan = 0;
 513
 514     if (!strcmp(str, "null"))
 515         /* null */
 516         return &null_hci;
 517     else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
 518         /* host[:hciN] */
 519         return bt_host_hci(str[4] ? str + 5 : "hci0");
 520     else if (!strncmp(str, "hci", 3)) {
 521         /* hci[,vlan=n] */
 522         if (str[3]) {
 523             if (!strncmp(str + 3, ",vlan=", 6)) {
 524                 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
 525                 if (*endp)
 526                     vlan = 0;
 527             }
 528         } else
 529             vlan = qemu_find_bt_vlan(0);
 530         if (vlan)
 531            return bt_new_hci(vlan);
 532     }
 533
 534     fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
 535
 536     return 0;
 537 }
 538
 539 static int bt_hci_parse(const char *str)
 540 {
 541     struct HCIInfo *hci;
 542     bdaddr_t bdaddr;
 543
 544     if (nb_hcis >= MAX_NICS) {
 545         fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
 546         return -1;
 547     }
 548
 549     hci = hci_init(str);
 550     if (!hci)
 551         return -1;
 552
 553     bdaddr.b[0] = 0x52;
 554     bdaddr.b[1] = 0x54;
 555     bdaddr.b[2] = 0x00;
 556     bdaddr.b[3] = 0x12;
 557     bdaddr.b[4] = 0x34;
 558     bdaddr.b[5] = 0x56 + nb_hcis;
 559     hci->bdaddr_set(hci, bdaddr.b);
 560
 561     hci_table[nb_hcis++] = hci;
 562
 563     return 0;
 564 }
 565
 566 static void bt_vhci_add(int vlan_id)
 567 {
 568     struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
 569
 570     if (!vlan->slave)
 571         fprintf(stderr, "qemu: warning: adding a VHCI to "
 572                         "an empty scatternet %i\n", vlan_id);
 573
 574     bt_vhci_init(bt_new_hci(vlan));
 575 }
 576
 577 static struct bt_device_s *bt_device_add(const char *opt)
 578 {
 579     struct bt_scatternet_s *vlan;
 580     int vlan_id = 0;
 581     char *endp = strstr(opt, ",vlan=");
 582     int len = (endp ? endp - opt : strlen(opt)) + 1;
 583     char devname[10];
 584
 585     pstrcpy(devname, MIN(sizeof(devname), len), opt);
 586
 587     if (endp) {
 588         vlan_id = strtol(endp + 6, &endp, 0);
 589         if (*endp) {
 590             fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
 591             return 0;
 592         }
 593     }
 594
 595     vlan = qemu_find_bt_vlan(vlan_id);
 596
 597     if (!vlan->slave)
 598         fprintf(stderr, "qemu: warning: adding a slave device to "
 599                         "an empty scatternet %i\n", vlan_id);
 600
 601     if (!strcmp(devname, "keyboard"))
 602         return bt_keyboard_init(vlan);
 603
 604     fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
 605     return 0;
 606 }
 607
 608 static int bt_parse(const char *opt)
 609 {
 610     const char *endp, *p;
 611     int vlan;
 612
 613     if (strstart(opt, "hci", &endp)) {
 614         if (!*endp || *endp == ',') {
 615             if (*endp)
 616                 if (!strstart(endp, ",vlan=", 0))
 617                     opt = endp + 1;
 618
 619             return bt_hci_parse(opt);
 620        }
 621     } else if (strstart(opt, "vhci", &endp)) {
 622         if (!*endp || *endp == ',') {
 623             if (*endp) {
 624                 if (strstart(endp, ",vlan=", &p)) {
 625                     vlan = strtol(p, (char **) &endp, 0);
 626                     if (*endp) {
 627                         fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
 628                         return 1;
 629                     }
 630                 } else {
 631                     fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
 632                     return 1;
 633                 }
 634             } else
 635                 vlan = 0;
 636
 637             bt_vhci_add(vlan);
 638             return 0;
 639         }
 640     } else if (strstart(opt, "device:", &endp))
 641         return !bt_device_add(endp);
 642
 643     fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
 644     return 1;
 645 }
 646
 647 /***********************************************************/
 648 /* QEMU Block devices */
 649
 650 #define HD_ALIAS "index=%d,media=disk"
 651 #define CDROM_ALIAS "index=2,media=cdrom"
 652 #define FD_ALIAS "index=%d,if=floppy"
 653 #define PFLASH_ALIAS "if=pflash"
 654 #define MTD_ALIAS "if=mtd"
 655 #define SD_ALIAS "index=0,if=sd"
 656
 657 QemuOpts *drive_add(const char *file, const char *fmt, ...)
 658 {
 659     va_list ap;
 660     char optstr[1024];
 661     QemuOpts *opts;
 662
 663     va_start(ap, fmt);
 664     vsnprintf(optstr, sizeof(optstr), fmt, ap);
 665     va_end(ap);
 666
 667     opts = qemu_opts_parse(&qemu_drive_opts, optstr, 0);
 668     if (!opts) {
 669         return NULL;
 670     }
 671     if (file)
 672         qemu_opt_set(opts, "file", file);
 673     return opts;
 674 }
 675
 676 DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
 677 {
 678     DriveInfo *dinfo;
 679
 680     /* seek interface, bus and unit */
 681
 682     QTAILQ_FOREACH(dinfo, &drives, next) {
 683         if (dinfo->type == type &&
 684             dinfo->bus == bus &&
 685             dinfo->unit == unit)
 686             return dinfo;
 687     }
 688
 689     return NULL;
 690 }
 691
 692 DriveInfo *drive_get_by_id(const char *id)
 693 {
 694     DriveInfo *dinfo;
 695
 696     QTAILQ_FOREACH(dinfo, &drives, next) {
 697         if (strcmp(id, dinfo->id))
 698             continue;
 699         return dinfo;
 700     }
 701     return NULL;
 702 }
 703
 704 int drive_get_max_bus(BlockInterfaceType type)
 705 {
 706     int max_bus;
 707     DriveInfo *dinfo;
 708
 709     max_bus = -1;
 710     QTAILQ_FOREACH(dinfo, &drives, next) {
 711         if(dinfo->type == type &&
 712            dinfo->bus > max_bus)
 713             max_bus = dinfo->bus;
 714     }
 715     return max_bus;
 716 }
 717
 718 const char *drive_get_serial(BlockDriverState *bdrv)
 719 {
 720     DriveInfo *dinfo;
 721
 722     QTAILQ_FOREACH(dinfo, &drives, next) {
 723         if (dinfo->bdrv == bdrv)
 724             return dinfo->serial;
 725     }
 726
 727     return "\0";
 728 }
 729
 730 BlockInterfaceErrorAction drive_get_on_error(
 731     BlockDriverState *bdrv, int is_read)
 732 {
 733     DriveInfo *dinfo;
 734
 735     QTAILQ_FOREACH(dinfo, &drives, next) {
 736         if (dinfo->bdrv == bdrv)
 737             return is_read ? dinfo->on_read_error : dinfo->on_write_error;
 738     }
 739
 740     return is_read ? BLOCK_ERR_REPORT : BLOCK_ERR_STOP_ENOSPC;
 741 }
 742
 743 static void bdrv_format_print(void *opaque, const char *name)
 744 {
 745     fprintf(stderr, " %s", name);
 746 }
 747
 748 void drive_uninit(DriveInfo *dinfo)
 749 {
 750     qemu_opts_del(dinfo->opts);
 751     bdrv_delete(dinfo->bdrv);
 752     QTAILQ_REMOVE(&drives, dinfo, next);
 753     qemu_free(dinfo);
 754 }
 755
 756 static int parse_block_error_action(const char *buf, int is_read)
 757 {
 758     if (!strcmp(buf, "ignore")) {
 759         return BLOCK_ERR_IGNORE;
 760     } else if (!is_read && !strcmp(buf, "enospc")) {
 761         return BLOCK_ERR_STOP_ENOSPC;
 762     } else if (!strcmp(buf, "stop")) {
 763         return BLOCK_ERR_STOP_ANY;
 764     } else if (!strcmp(buf, "report")) {
 765         return BLOCK_ERR_REPORT;
 766     } else {
 767         fprintf(stderr, "qemu: '%s' invalid %s error action\n",
 768             buf, is_read ? "read" : "write");
 769         return -1;
 770     }
 771 }
 772
 773 DriveInfo *drive_init(QemuOpts *opts, void *opaque,
 774                       int *fatal_error)
 775 {
 776     const char *buf;
 777     const char *file = NULL;
 778     char devname[128];
 779     const char *serial;
 780     const char *mediastr = "";
 781     BlockInterfaceType type;
 782     enum { MEDIA_DISK, MEDIA_CDROM } media;
 783     int bus_id, unit_id;
 784     int cyls, heads, secs, translation;
 785     BlockDriver *drv = NULL;
 786     QEMUMachine *machine = opaque;
 787     int max_devs;
 788     int index;
 789     int ro = 0;
 790     int bdrv_flags = 0;
 791     int on_read_error, on_write_error;
 792     const char *devaddr;
 793     DriveInfo *dinfo;
 794     int snapshot = 0;
 795
 796     *fatal_error = 1;
 797
 798     translation = BIOS_ATA_TRANSLATION_AUTO;
 799
 800     if (machine && machine->use_scsi) {
 801         type = IF_SCSI;
 802         max_devs = MAX_SCSI_DEVS;
 803         pstrcpy(devname, sizeof(devname), "scsi");
 804     } else {
 805         type = IF_IDE;
 806         max_devs = MAX_IDE_DEVS;
 807         pstrcpy(devname, sizeof(devname), "ide");
 808     }
 809     media = MEDIA_DISK;
 810
 811     /* extract parameters */
 812     bus_id  = qemu_opt_get_number(opts, "bus", 0);
 813     unit_id = qemu_opt_get_number(opts, "unit", -1);
 814     index   = qemu_opt_get_number(opts, "index", -1);
 815
 816     cyls  = qemu_opt_get_number(opts, "cyls", 0);
 817     heads = qemu_opt_get_number(opts, "heads", 0);
 818     secs  = qemu_opt_get_number(opts, "secs", 0);
 819
 820     snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
 821     ro = qemu_opt_get_bool(opts, "readonly", 0);
 822
 823     file = qemu_opt_get(opts, "file");
 824     serial = qemu_opt_get(opts, "serial");
 825
 826     if ((buf = qemu_opt_get(opts, "if")) != NULL) {
 827         pstrcpy(devname, sizeof(devname), buf);
 828         if (!strcmp(buf, "ide")) {
 829             type = IF_IDE;
 830             max_devs = MAX_IDE_DEVS;
 831         } else if (!strcmp(buf, "scsi")) {
 832             type = IF_SCSI;
 833             max_devs = MAX_SCSI_DEVS;
 834         } else if (!strcmp(buf, "floppy")) {
 835             type = IF_FLOPPY;
 836             max_devs = 0;
 837         } else if (!strcmp(buf, "pflash")) {
 838             type = IF_PFLASH;
 839             max_devs = 0;
 840         } else if (!strcmp(buf, "mtd")) {
 841             type = IF_MTD;
 842             max_devs = 0;
 843         } else if (!strcmp(buf, "sd")) {
 844             type = IF_SD;
 845             max_devs = 0;
 846         } else if (!strcmp(buf, "virtio")) {
 847             type = IF_VIRTIO;
 848             max_devs = 0;
 849         } else if (!strcmp(buf, "xen")) {
 850             type = IF_XEN;
 851             max_devs = 0;
 852         } else if (!strcmp(buf, "none")) {
 853             type = IF_NONE;
 854             max_devs = 0;
 855         } else {
 856             fprintf(stderr, "qemu: unsupported bus type '%s'\n", buf);
 857             return NULL;
 858         }
 859     }
 860
 861     if (cyls || heads || secs) {
 862         if (cyls < 1 || (type == IF_IDE && cyls > 16383)) {
 863             fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", buf);
 864             return NULL;
 865         }
 866         if (heads < 1 || (type == IF_IDE && heads > 16)) {
 867             fprintf(stderr, "qemu: '%s' invalid physical heads number\n", buf);
 868             return NULL;
 869         }
 870         if (secs < 1 || (type == IF_IDE && secs > 63)) {
 871             fprintf(stderr, "qemu: '%s' invalid physical secs number\n", buf);
 872             return NULL;
 873         }
 874     }
 875
 876     if ((buf = qemu_opt_get(opts, "trans")) != NULL) {
 877         if (!cyls) {
 878             fprintf(stderr,
 879                     "qemu: '%s' trans must be used with cyls,heads and secs\n",
 880                     buf);
 881             return NULL;
 882         }
 883         if (!strcmp(buf, "none"))
 884             translation = BIOS_ATA_TRANSLATION_NONE;
 885         else if (!strcmp(buf, "lba"))
 886             translation = BIOS_ATA_TRANSLATION_LBA;
 887         else if (!strcmp(buf, "auto"))
 888             translation = BIOS_ATA_TRANSLATION_AUTO;
 889         else {
 890             fprintf(stderr, "qemu: '%s' invalid translation type\n", buf);
 891             return NULL;
 892         }
 893     }
 894
 895     if ((buf = qemu_opt_get(opts, "media")) != NULL) {
 896         if (!strcmp(buf, "disk")) {
 897             media = MEDIA_DISK;
 898         } else if (!strcmp(buf, "cdrom")) {
 899             if (cyls || secs || heads) {
 900                 fprintf(stderr,
 901                         "qemu: '%s' invalid physical CHS format\n", buf);
 902                 return NULL;
 903             }
 904             media = MEDIA_CDROM;
 905         } else {
 906             fprintf(stderr, "qemu: '%s' invalid media\n", buf);
 907             return NULL;
 908         }
 909     }
 910
 911     if ((buf = qemu_opt_get(opts, "cache")) != NULL) {
 912         if (!strcmp(buf, "off") || !strcmp(buf, "none")) {
 913             bdrv_flags |= BDRV_O_NOCACHE;
 914         } else if (!strcmp(buf, "writeback")) {
 915             bdrv_flags |= BDRV_O_CACHE_WB;
 916         } else if (!strcmp(buf, "writethrough")) {
 917             /* this is the default */
 918         } else {
 919            fprintf(stderr, "qemu: invalid cache option\n");
 920            return NULL;
 921         }
 922     }
 923
 924 #ifdef CONFIG_LINUX_AIO
 925     if ((buf = qemu_opt_get(opts, "aio")) != NULL) {
 926         if (!strcmp(buf, "native")) {
 927             bdrv_flags |= BDRV_O_NATIVE_AIO;
 928         } else if (!strcmp(buf, "threads")) {
 929             /* this is the default */
 930         } else {
 931            fprintf(stderr, "qemu: invalid aio option\n");
 932            return NULL;
 933         }
 934     }
 935 #endif
 936
 937     if ((buf = qemu_opt_get(opts, "format")) != NULL) {
 938        if (strcmp(buf, "?") == 0) {
 939             fprintf(stderr, "qemu: Supported formats:");
 940             bdrv_iterate_format(bdrv_format_print, NULL);
 941             fprintf(stderr, "\n");
 942             return NULL;
 943         }
 944         drv = bdrv_find_whitelisted_format(buf);
 945         if (!drv) {
 946             fprintf(stderr, "qemu: '%s' invalid format\n", buf);
 947             return NULL;
 948         }
 949     }
 950
 951     on_write_error = BLOCK_ERR_STOP_ENOSPC;
 952     if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
 953         if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
 954             fprintf(stderr, "werror is no supported by this format\n");
 955             return NULL;
 956         }
 957
 958         on_write_error = parse_block_error_action(buf, 0);
 959         if (on_write_error < 0) {
 960             return NULL;
 961         }
 962     }
 963
 964     on_read_error = BLOCK_ERR_REPORT;
 965     if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
 966         if (type != IF_IDE && type != IF_VIRTIO) {
 967             fprintf(stderr, "rerror is no supported by this format\n");
 968             return NULL;
 969         }
 970
 971         on_read_error = parse_block_error_action(buf, 1);
 972         if (on_read_error < 0) {
 973             return NULL;
 974         }
 975     }
 976
 977     if ((devaddr = qemu_opt_get(opts, "addr")) != NULL) {
 978         if (type != IF_VIRTIO) {
 979             fprintf(stderr, "addr is not supported\n");
 980             return NULL;
 981         }
 982     }
 983
 984     /* compute bus and unit according index */
 985
 986     if (index != -1) {
 987         if (bus_id != 0 || unit_id != -1) {
 988             fprintf(stderr,
 989                     "qemu: index cannot be used with bus and unit\n");
 990             return NULL;
 991         }
 992         if (max_devs == 0)
 993         {
 994             unit_id = index;
 995             bus_id = 0;
 996         } else {
 997             unit_id = index % max_devs;
 998             bus_id = index / max_devs;
 999         }
1000     }
1001
1002     /* if user doesn't specify a unit_id,
1003      * try to find the first free
1004      */
1005
1006     if (unit_id == -1) {
1007        unit_id = 0;
1008        while (drive_get(type, bus_id, unit_id) != NULL) {
1009            unit_id++;
1010            if (max_devs && unit_id >= max_devs) {
1011                unit_id -= max_devs;
1012                bus_id++;
1013            }
1014        }
1015     }
1016
1017     /* check unit id */
1018
1019     if (max_devs && unit_id >= max_devs) {
1020         fprintf(stderr, "qemu: unit %d too big (max is %d)\n",
1021                 unit_id, max_devs - 1);
1022         return NULL;
1023     }
1024
1025     /*
1026      * ignore multiple definitions
1027      */
1028
1029     if (drive_get(type, bus_id, unit_id) != NULL) {
1030         *fatal_error = 0;
1031         return NULL;
1032     }
1033
1034     /* init */
1035
1036     dinfo = qemu_mallocz(sizeof(*dinfo));
1037     if ((buf = qemu_opts_id(opts)) != NULL) {
1038         dinfo->id = qemu_strdup(buf);
1039     } else {
1040         /* no id supplied -> create one */
1041         dinfo->id = qemu_mallocz(32);
1042         if (type == IF_IDE || type == IF_SCSI)
1043             mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
1044         if (max_devs)
1045             snprintf(dinfo->id, 32, "%s%i%s%i",
1046                      devname, bus_id, mediastr, unit_id);
1047         else
1048             snprintf(dinfo->id, 32, "%s%s%i",
1049                      devname, mediastr, unit_id);
1050     }
1051     dinfo->bdrv = bdrv_new(dinfo->id);
1052     dinfo->devaddr = devaddr;
1053     dinfo->type = type;
1054     dinfo->bus = bus_id;
1055     dinfo->unit = unit_id;
1056     dinfo->on_read_error = on_read_error;
1057     dinfo->on_write_error = on_write_error;
1058     dinfo->opts = opts;
1059     if (serial)
1060         strncpy(dinfo->serial, serial, sizeof(serial));
1061     QTAILQ_INSERT_TAIL(&drives, dinfo, next);
1062
1063     switch(type) {
1064     case IF_IDE:
1065     case IF_SCSI:
1066     case IF_XEN:
1067     case IF_NONE:
1068         switch(media) {
1069         case MEDIA_DISK:
1070             if (cyls != 0) {
1071                 bdrv_set_geometry_hint(dinfo->bdrv, cyls, heads, secs);
1072                 bdrv_set_translation_hint(dinfo->bdrv, translation);
1073             }
1074             break;
1075         case MEDIA_CDROM:
1076             bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_CDROM);
1077             break;
1078         }
1079         break;
1080     case IF_SD:
1081         /* FIXME: This isn't really a floppy, but it's a reasonable
1082            approximation.  */
1083     case IF_FLOPPY:
1084         bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_FLOPPY);
1085         break;
1086     case IF_PFLASH:
1087     case IF_MTD:
1088         break;
1089     case IF_VIRTIO:
1090         /* add virtio block device */
1091         opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
1092         qemu_opt_set(opts, "driver", "virtio-blk-pci");
1093         qemu_opt_set(opts, "drive", dinfo->id);
1094         if (devaddr)
1095             qemu_opt_set(opts, "addr", devaddr);
1096         break;
1097     case IF_COUNT:
1098         abort();
1099     }
1100     if (!file) {
1101         *fatal_error = 0;
1102         return NULL;
1103     }
1104     if (snapshot) {
1105         /* always use write-back with snapshot */
1106         bdrv_flags &= ~BDRV_O_CACHE_MASK;
1107         bdrv_flags |= (BDRV_O_SNAPSHOT|BDRV_O_CACHE_WB);
1108     }
1109
1110     if (media == MEDIA_CDROM) {
1111         /* CDROM is fine for any interface, don't check.  */
1112         ro = 1;
1113     } else if (ro == 1) {
1114         if (type != IF_SCSI && type != IF_VIRTIO && type != IF_FLOPPY) {
1115             fprintf(stderr, "qemu: readonly flag not supported for drive with this interface\n");
1116             return NULL;
1117         }
1118     }
1119
1120     bdrv_flags |= ro ? 0 : BDRV_O_RDWR;
1121
1122     if (bdrv_open(dinfo->bdrv, file, bdrv_flags, drv) < 0) {
1123         fprintf(stderr, "qemu: could not open disk image %s: %s\n",
1124                         file, strerror(errno));
1125         return NULL;
1126     }
1127
1128     if (bdrv_key_required(dinfo->bdrv))
1129         autostart = 0;
1130     *fatal_error = 0;
1131     return dinfo;
1132 }
1133
1134 static int drive_init_func(QemuOpts *opts, void *opaque)
1135 {
1136     QEMUMachine *machine = opaque;
1137     int fatal_error = 0;
1138
1139     if (drive_init(opts, machine, &fatal_error) == NULL) {
1140         if (fatal_error)
1141             return 1;
1142     }
1143     return 0;
1144 }
1145
1146 static int drive_enable_snapshot(QemuOpts *opts, void *opaque)
1147 {
1148     if (NULL == qemu_opt_get(opts, "snapshot")) {
1149         qemu_opt_set(opts, "snapshot", "on");
1150     }
1151     return 0;
1152 }
1153
1154 void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
1155 {
1156     boot_set_handler = func;
1157     boot_set_opaque = opaque;
1158 }
1159
1160 int qemu_boot_set(const char *boot_devices)
1161 {
1162     if (!boot_set_handler) {
1163         return -EINVAL;
1164     }
1165     return boot_set_handler(boot_set_opaque, boot_devices);
1166 }
1167
1168 static void validate_bootdevices(char *devices)
1169 {
1170     /* We just do some generic consistency checks */
1171     const char *p;
1172     int bitmap = 0;
1173
1174     for (p = devices; *p != '\0'; p++) {
1175         /* Allowed boot devices are:
1176          * a-b: floppy disk drives
1177          * c-f: IDE disk drives
1178          * g-m: machine implementation dependant drives
1179          * n-p: network devices
1180          * It's up to each machine implementation to check if the given boot
1181          * devices match the actual hardware implementation and firmware
1182          * features.
1183          */
1184         if (*p < 'a' || *p > 'p') {
1185             fprintf(stderr, "Invalid boot device '%c'\n", *p);
1186             exit(1);
1187         }
1188         if (bitmap & (1 << (*p - 'a'))) {
1189             fprintf(stderr, "Boot device '%c' was given twice\n", *p);
1190             exit(1);
1191         }
1192         bitmap |= 1 << (*p - 'a');
1193     }
1194 }
1195
1196 static void restore_boot_devices(void *opaque)
1197 {
1198     char *standard_boot_devices = opaque;
1199     static int first = 1;
1200
1201     /* Restore boot order and remove ourselves after the first boot */
1202     if (first) {
1203         first = 0;
1204         return;
1205     }
1206
1207     qemu_boot_set(standard_boot_devices);
1208
1209     qemu_unregister_reset(restore_boot_devices, standard_boot_devices);
1210     qemu_free(standard_boot_devices);
1211 }
1212
1213 static void numa_add(const char *optarg)
1214 {
1215     char option[128];
1216     char *endptr;
1217     unsigned long long value, endvalue;
1218     int nodenr;
1219
1220     optarg = get_opt_name(option, 128, optarg, ',') + 1;
1221     if (!strcmp(option, "node")) {
1222         if (get_param_value(option, 128, "nodeid", optarg) == 0) {
1223             nodenr = nb_numa_nodes;
1224         } else {
1225             nodenr = strtoull(option, NULL, 10);
1226         }
1227
1228         if (get_param_value(option, 128, "mem", optarg) == 0) {
1229             node_mem[nodenr] = 0;
1230         } else {
1231             value = strtoull(option, &endptr, 0);
1232             switch (*endptr) {
1233             case 0: case 'M': case 'm':
1234                 value <<= 20;
1235                 break;
1236             case 'G': case 'g':
1237                 value <<= 30;
1238                 break;
1239             }
1240             node_mem[nodenr] = value;
1241         }
1242         if (get_param_value(option, 128, "cpus", optarg) == 0) {
1243             node_cpumask[nodenr] = 0;
1244         } else {
1245             value = strtoull(option, &endptr, 10);
1246             if (value >= 64) {
1247                 value = 63;
1248                 fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
1249             } else {
1250                 if (*endptr == '-') {
1251                     endvalue = strtoull(endptr+1, &endptr, 10);
1252                     if (endvalue >= 63) {
1253                         endvalue = 62;
1254                         fprintf(stderr,
1255                             "only 63 CPUs in NUMA mode supported.\n");
1256                     }
1257                     value = (2ULL << endvalue) - (1ULL << value);
1258                 } else {
1259                     value = 1ULL << value;
1260                 }
1261             }
1262             node_cpumask[nodenr] = value;
1263         }
1264         nb_numa_nodes++;
1265     }
1266     return;
1267 }
1268
1269 static void smp_parse(const char *optarg)
1270 {
1271     int smp, sockets = 0, threads = 0, cores = 0;
1272     char *endptr;
1273     char option[128];
1274
1275     smp = strtoul(optarg, &endptr, 10);
1276     if (endptr != optarg) {
1277         if (*endptr == ',') {
1278             endptr++;
1279         }
1280     }
1281     if (get_param_value(option, 128, "sockets", endptr) != 0)
1282         sockets = strtoull(option, NULL, 10);
1283     if (get_param_value(option, 128, "cores", endptr) != 0)
1284         cores = strtoull(option, NULL, 10);
1285     if (get_param_value(option, 128, "threads", endptr) != 0)
1286         threads = strtoull(option, NULL, 10);
1287     if (get_param_value(option, 128, "maxcpus", endptr) != 0)
1288         max_cpus = strtoull(option, NULL, 10);
1289
1290     /* compute missing values, prefer sockets over cores over threads */
1291     if (smp == 0 || sockets == 0) {
1292         sockets = sockets > 0 ? sockets : 1;
1293         cores = cores > 0 ? cores : 1;
1294         threads = threads > 0 ? threads : 1;
1295         if (smp == 0) {
1296             smp = cores * threads * sockets;
1297         }
1298     } else {
1299         if (cores == 0) {
1300             threads = threads > 0 ? threads : 1;
1301             cores = smp / (sockets * threads);
1302         } else {
1303             if (sockets) {
1304                 threads = smp / (cores * sockets);
1305             }
1306         }
1307     }
1308     smp_cpus = smp;
1309     smp_cores = cores > 0 ? cores : 1;
1310     smp_threads = threads > 0 ? threads : 1;
1311     if (max_cpus == 0)
1312         max_cpus = smp_cpus;
1313 }
1314
1315 /***********************************************************/
1316 /* USB devices */
1317
1318 static int usb_device_add(const char *devname, int is_hotplug)
1319 {
1320     const char *p;
1321     USBDevice *dev = NULL;
1322
1323     if (!usb_enabled)
1324         return -1;
1325
1326     /* drivers with .usbdevice_name entry in USBDeviceInfo */
1327     dev = usbdevice_create(devname);
1328     if (dev)
1329         goto done;
1330
1331     /* the other ones */
1332     if (strstart(devname, "host:", &p)) {
1333         dev = usb_host_device_open(p);
1334     } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
1335         dev = usb_bt_init(devname[2] ? hci_init(p) :
1336                         bt_new_hci(qemu_find_bt_vlan(0)));
1337     } else {
1338         return -1;
1339     }
1340     if (!dev)
1341         return -1;
1342
1343 done:
1344     return 0;
1345 }
1346
1347 static int usb_device_del(const char *devname)
1348 {
1349     int bus_num, addr;
1350     const char *p;
1351
1352     if (strstart(devname, "host:", &p))
1353         return usb_host_device_close(p);
1354
1355     if (!usb_enabled)
1356         return -1;
1357
1358     p = strchr(devname, '.');
1359     if (!p)
1360         return -1;
1361     bus_num = strtoul(devname, NULL, 0);
1362     addr = strtoul(p + 1, NULL, 0);
1363
1364     return usb_device_delete_addr(bus_num, addr);
1365 }
1366
1367 static int usb_parse(const char *cmdline)
1368 {
1369     int r;
1370     r = usb_device_add(cmdline, 0);
1371     if (r < 0) {
1372         fprintf(stderr, "qemu: could not add USB device '%s'\n", cmdline);
1373     }
1374     return r;
1375 }
1376
1377 void do_usb_add(Monitor *mon, const QDict *qdict)
1378 {
1379     const char *devname = qdict_get_str(qdict, "devname");
1380     if (usb_device_add(devname, 1) < 0) {
1381         error_report("could not add USB device '%s'", devname);
1382     }
1383 }
1384
1385 void do_usb_del(Monitor *mon, const QDict *qdict)
1386 {
1387     const char *devname = qdict_get_str(qdict, "devname");
1388     if (usb_device_del(devname) < 0) {
1389         error_report("could not delete USB device '%s'", devname);
1390     }
1391 }
1392
1393 /***********************************************************/
1394 /* PCMCIA/Cardbus */
1395
1396 static struct pcmcia_socket_entry_s {
1397     PCMCIASocket *socket;
1398     struct pcmcia_socket_entry_s *next;
1399 } *pcmcia_sockets = 0;
1400
1401 void pcmcia_socket_register(PCMCIASocket *socket)
1402 {
1403     struct pcmcia_socket_entry_s *entry;
1404
1405     entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
1406     entry->socket = socket;
1407     entry->next = pcmcia_sockets;
1408     pcmcia_sockets = entry;
1409 }
1410
1411 void pcmcia_socket_unregister(PCMCIASocket *socket)
1412 {
1413     struct pcmcia_socket_entry_s *entry, **ptr;
1414
1415     ptr = &pcmcia_sockets;
1416     for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
1417         if (entry->socket == socket) {
1418             *ptr = entry->next;
1419             qemu_free(entry);
1420         }
1421 }
1422
1423 void pcmcia_info(Monitor *mon)
1424 {
1425     struct pcmcia_socket_entry_s *iter;
1426
1427     if (!pcmcia_sockets)
1428         monitor_printf(mon, "No PCMCIA sockets\n");
1429
1430     for (iter = pcmcia_sockets; iter; iter = iter->next)
1431         monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
1432                        iter->socket->attached ? iter->socket->card_string :
1433                        "Empty");
1434 }
1435
1436 /***********************************************************/
1437 /* I/O handling */
1438
1439 typedef struct IOHandlerRecord {
1440     int fd;
1441     IOCanReadHandler *fd_read_poll;
1442     IOHandler *fd_read;
1443     IOHandler *fd_write;
1444     int deleted;
1445     void *opaque;
1446     /* temporary data */
1447     struct pollfd *ufd;
1448     QLIST_ENTRY(IOHandlerRecord) next;
1449 } IOHandlerRecord;
1450
1451 static QLIST_HEAD(, IOHandlerRecord) io_handlers =
1452     QLIST_HEAD_INITIALIZER(io_handlers);
1453
1454
1455 /* XXX: fd_read_poll should be suppressed, but an API change is
1456    necessary in the character devices to suppress fd_can_read(). */
1457 int qemu_set_fd_handler2(int fd,
1458                          IOCanReadHandler *fd_read_poll,
1459                          IOHandler *fd_read,
1460                          IOHandler *fd_write,
1461                          void *opaque)
1462 {
1463     IOHandlerRecord *ioh;
1464
1465     if (!fd_read && !fd_write) {
1466         QLIST_FOREACH(ioh, &io_handlers, next) {
1467             if (ioh->fd == fd) {
1468                 ioh->deleted = 1;
1469                 break;
1470             }
1471         }
1472     } else {
1473         QLIST_FOREACH(ioh, &io_handlers, next) {
1474             if (ioh->fd == fd)
1475                 goto found;
1476         }
1477         ioh = qemu_mallocz(sizeof(IOHandlerRecord));
1478         QLIST_INSERT_HEAD(&io_handlers, ioh, next);
1479     found:
1480         ioh->fd = fd;
1481         ioh->fd_read_poll = fd_read_poll;
1482         ioh->fd_read = fd_read;
1483         ioh->fd_write = fd_write;
1484         ioh->opaque = opaque;
1485         ioh->deleted = 0;
1486     }
1487     return 0;
1488 }
1489
1490 int qemu_set_fd_handler(int fd,
1491                         IOHandler *fd_read,
1492                         IOHandler *fd_write,
1493                         void *opaque)
1494 {
1495     return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
1496 }
1497
1498 #ifdef _WIN32
1499 /***********************************************************/
1500 /* Polling handling */
1501
1502 typedef struct PollingEntry {
1503     PollingFunc *func;
1504     void *opaque;
1505     struct PollingEntry *next;
1506 } PollingEntry;
1507
1508 static PollingEntry *first_polling_entry;
1509
1510 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
1511 {
1512     PollingEntry **ppe, *pe;
1513     pe = qemu_mallocz(sizeof(PollingEntry));
1514     pe->func = func;
1515     pe->opaque = opaque;
1516     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
1517     *ppe = pe;
1518     return 0;
1519 }
1520
1521 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
1522 {
1523     PollingEntry **ppe, *pe;
1524     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
1525         pe = *ppe;
1526         if (pe->func == func && pe->opaque == opaque) {
1527             *ppe = pe->next;
1528             qemu_free(pe);
1529             break;
1530         }
1531     }
1532 }
1533
1534 /***********************************************************/
1535 /* Wait objects support */
1536 typedef struct WaitObjects {
1537     int num;
1538     HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
1539     WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
1540     void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
1541 } WaitObjects;
1542
1543 static WaitObjects wait_objects = {0};
1544
1545 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
1546 {
1547     WaitObjects *w = &wait_objects;
1548
1549     if (w->num >= MAXIMUM_WAIT_OBJECTS)
1550         return -1;
1551     w->events[w->num] = handle;
1552     w->func[w->num] = func;
1553     w->opaque[w->num] = opaque;
1554     w->num++;
1555     return 0;
1556 }
1557
1558 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
1559 {
1560     int i, found;
1561     WaitObjects *w = &wait_objects;
1562
1563     found = 0;
1564     for (i = 0; i < w->num; i++) {
1565         if (w->events[i] == handle)
1566             found = 1;
1567         if (found) {
1568             w->events[i] = w->events[i + 1];
1569             w->func[i] = w->func[i + 1];
1570             w->opaque[i] = w->opaque[i + 1];
1571         }
1572     }
1573     if (found)
1574         w->num--;
1575 }
1576 #endif
1577
1578 /***********************************************************/
1579 /* machine registration */
1580
1581 static QEMUMachine *first_machine = NULL;
1582 QEMUMachine *current_machine = NULL;
1583
1584 int qemu_register_machine(QEMUMachine *m)
1585 {
1586     QEMUMachine **pm;
1587     pm = &first_machine;
1588     while (*pm != NULL)
1589         pm = &(*pm)->next;
1590     m->next = NULL;
1591     *pm = m;
1592     return 0;
1593 }
1594
1595 static QEMUMachine *find_machine(const char *name)
1596 {
1597     QEMUMachine *m;
1598
1599     for(m = first_machine; m != NULL; m = m->next) {
1600         if (!strcmp(m->name, name))
1601             return m;
1602         if (m->alias && !strcmp(m->alias, name))
1603             return m;
1604     }
1605     return NULL;
1606 }
1607
1608 static QEMUMachine *find_default_machine(void)
1609 {
1610     QEMUMachine *m;
1611
1612     for(m = first_machine; m != NULL; m = m->next) {
1613         if (m->is_default) {
1614             return m;
1615         }
1616     }
1617     return NULL;
1618 }
1619
1620 /***********************************************************/
1621 /* main execution loop */
1622
1623 static void gui_update(void *opaque)
1624 {
1625     uint64_t interval = GUI_REFRESH_INTERVAL;
1626     DisplayState *ds = opaque;
1627     DisplayChangeListener *dcl = ds->listeners;
1628
1629     qemu_flush_coalesced_mmio_buffer();
1630     dpy_refresh(ds);
1631
1632     while (dcl != NULL) {
1633         if (dcl->gui_timer_interval &&
1634             dcl->gui_timer_interval < interval)
1635             interval = dcl->gui_timer_interval;
1636         dcl = dcl->next;
1637     }
1638     qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
1639 }
1640
1641 static void nographic_update(void *opaque)
1642 {
1643     uint64_t interval = GUI_REFRESH_INTERVAL;
1644
1645     qemu_flush_coalesced_mmio_buffer();
1646     qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
1647 }
1648
1649 struct vm_change_state_entry {
1650     VMChangeStateHandler *cb;
1651     void *opaque;
1652     QLIST_ENTRY (vm_change_state_entry) entries;
1653 };
1654
1655 static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
1656
1657 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
1658                                                      void *opaque)
1659 {
1660     VMChangeStateEntry *e;
1661
1662     e = qemu_mallocz(sizeof (*e));
1663
1664     e->cb = cb;
1665     e->opaque = opaque;
1666     QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
1667     return e;
1668 }
1669
1670 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
1671 {
1672     QLIST_REMOVE (e, entries);
1673     qemu_free (e);
1674 }
1675
1676 void vm_state_notify(int running, int reason)
1677 {
1678     VMChangeStateEntry *e;
1679
1680     for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
1681         e->cb(e->opaque, running, reason);
1682     }
1683 }
1684
1685 void vm_start(void)
1686 {
1687     if (!vm_running) {
1688         cpu_enable_ticks();
1689         vm_running = 1;
1690         vm_state_notify(1, 0);
1691         resume_all_vcpus();
1692         monitor_protocol_event(QEVENT_RESUME, NULL);
1693     }
1694 }
1695
1696 /* reset/shutdown handler */
1697
1698 typedef struct QEMUResetEntry {
1699     QTAILQ_ENTRY(QEMUResetEntry) entry;
1700     QEMUResetHandler *func;
1701     void *opaque;
1702 } QEMUResetEntry;
1703
1704 static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
1705     QTAILQ_HEAD_INITIALIZER(reset_handlers);
1706 static int reset_requested;
1707 static int shutdown_requested;
1708 static int powerdown_requested;
1709 int debug_requested;
1710 int vmstop_requested;
1711
1712 int qemu_shutdown_requested(void)
1713 {
1714     int r = shutdown_requested;
1715     shutdown_requested = 0;
1716     return r;
1717 }
1718
1719 int qemu_reset_requested(void)
1720 {
1721     int r = reset_requested;
1722     reset_requested = 0;
1723     return r;
1724 }
1725
1726 int qemu_powerdown_requested(void)
1727 {
1728     int r = powerdown_requested;
1729     powerdown_requested = 0;
1730     return r;
1731 }
1732
1733 static int qemu_debug_requested(void)
1734 {
1735     int r = debug_requested;
1736     debug_requested = 0;
1737     return r;
1738 }
1739
1740 static int qemu_vmstop_requested(void)
1741 {
1742     int r = vmstop_requested;
1743     vmstop_requested = 0;
1744     return r;
1745 }
1746
1747 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
1748 {
1749     QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
1750
1751     re->func = func;
1752     re->opaque = opaque;
1753     QTAILQ_INSERT_TAIL(&reset_handlers, re, entry);
1754 }
1755
1756 void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
1757 {
1758     QEMUResetEntry *re;
1759
1760     QTAILQ_FOREACH(re, &reset_handlers, entry) {
1761         if (re->func == func && re->opaque == opaque) {
1762             QTAILQ_REMOVE(&reset_handlers, re, entry);
1763             qemu_free(re);
1764             return;
1765         }
1766     }
1767 }
1768
1769 void qemu_system_reset(void)
1770 {
1771     QEMUResetEntry *re, *nre;
1772
1773     /* reset all devices */
1774     QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
1775         re->func(re->opaque);
1776     }
1777     monitor_protocol_event(QEVENT_RESET, NULL);
1778     cpu_synchronize_all_post_reset();
1779 }
1780
1781 void qemu_system_reset_request(void)
1782 {
1783     if (no_reboot) {
1784         shutdown_requested = 1;
1785     } else {
1786         reset_requested = 1;
1787     }
1788     qemu_notify_event();
1789 }
1790
1791 void qemu_system_shutdown_request(void)
1792 {
1793     shutdown_requested = 1;
1794     qemu_notify_event();
1795 }
1796
1797 void qemu_system_powerdown_request(void)
1798 {
1799     powerdown_requested = 1;
1800     qemu_notify_event();
1801 }
1802
1803 #ifdef _WIN32
1804 static void host_main_loop_wait(int *timeout)
1805 {
1806     int ret, ret2, i;
1807     PollingEntry *pe;
1808
1809
1810     /* XXX: need to suppress polling by better using win32 events */
1811     ret = 0;
1812     for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
1813         ret |= pe->func(pe->opaque);
1814     }
1815     if (ret == 0) {
1816         int err;
1817         WaitObjects *w = &wait_objects;
1818
1819         ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
1820         if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
1821             if (w->func[ret - WAIT_OBJECT_0])
1822                 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
1823
1824             /* Check for additional signaled events */
1825             for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
1826
1827                 /* Check if event is signaled */
1828                 ret2 = WaitForSingleObject(w->events[i], 0);
1829                 if(ret2 == WAIT_OBJECT_0) {
1830                     if (w->func[i])
1831                         w->func[i](w->opaque[i]);
1832                 } else if (ret2 == WAIT_TIMEOUT) {
1833                 } else {
1834                     err = GetLastError();
1835                     fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
1836                 }
1837             }
1838         } else if (ret == WAIT_TIMEOUT) {
1839         } else {
1840             err = GetLastError();
1841             fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
1842         }
1843     }
1844
1845     *timeout = 0;
1846 }
1847 #else
1848 static void host_main_loop_wait(int *timeout)
1849 {
1850 }
1851 #endif
1852
1853 void main_loop_wait(int nonblocking)
1854 {
1855     IOHandlerRecord *ioh;
1856     fd_set rfds, wfds, xfds;
1857     int ret, nfds;
1858     struct timeval tv;
1859     int timeout;
1860
1861     if (nonblocking)
1862         timeout = 0;
1863     else {
1864         timeout = qemu_calculate_timeout();
1865         qemu_bh_update_timeout(&timeout);
1866     }
1867
1868     host_main_loop_wait(&timeout);
1869
1870     /* poll any events */
1871     /* XXX: separate device handlers from system ones */
1872     nfds = -1;
1873     FD_ZERO(&rfds);
1874     FD_ZERO(&wfds);
1875     FD_ZERO(&xfds);
1876     QLIST_FOREACH(ioh, &io_handlers, next) {
1877         if (ioh->deleted)
1878             continue;
1879         if (ioh->fd_read &&
1880             (!ioh->fd_read_poll ||
1881              ioh->fd_read_poll(ioh->opaque) != 0)) {
1882             FD_SET(ioh->fd, &rfds);
1883             if (ioh->fd > nfds)
1884                 nfds = ioh->fd;
1885         }
1886         if (ioh->fd_write) {
1887             FD_SET(ioh->fd, &wfds);
1888             if (ioh->fd > nfds)
1889                 nfds = ioh->fd;
1890         }
1891     }
1892
1893     tv.tv_sec = timeout / 1000;
1894     tv.tv_usec = (timeout % 1000) * 1000;
1895
1896     slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
1897
1898     qemu_mutex_unlock_iothread();
1899     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
1900     qemu_mutex_lock_iothread();
1901     if (ret > 0) {
1902         IOHandlerRecord *pioh;
1903
1904         QLIST_FOREACH_SAFE(ioh, &io_handlers, next, pioh) {
1905             if (ioh->deleted) {
1906                 QLIST_REMOVE(ioh, next);
1907                 qemu_free(ioh);
1908                 continue;
1909             }
1910             if (ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
1911                 ioh->fd_read(ioh->opaque);
1912             }
1913             if (ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
1914                 ioh->fd_write(ioh->opaque);
1915             }
1916         }
1917     }
1918
1919     slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
1920
1921     qemu_run_all_timers();
1922
1923     /* Check bottom-halves last in case any of the earlier events triggered
1924        them.  */
1925     qemu_bh_poll();
1926
1927 }
1928
1929 static int vm_can_run(void)
1930 {
1931     if (powerdown_requested)
1932         return 0;
1933     if (reset_requested)
1934         return 0;
1935     if (shutdown_requested)
1936         return 0;
1937     if (debug_requested)
1938         return 0;
1939     return 1;
1940 }
1941
1942 qemu_irq qemu_system_powerdown;
1943
1944 static void main_loop(void)
1945 {
1946     int r;
1947
1948     qemu_main_loop_start();
1949
1950     for (;;) {
1951         do {
1952             bool nonblocking = false;
1953 #ifdef CONFIG_PROFILER
1954             int64_t ti;
1955 #endif
1956 #ifndef CONFIG_IOTHREAD
1957             nonblocking = tcg_cpu_exec();
1958 #endif
1959 #ifdef CONFIG_PROFILER
1960             ti = profile_getclock();
1961 #endif
1962             main_loop_wait(nonblocking);
1963 #ifdef CONFIG_PROFILER
1964             dev_time += profile_getclock() - ti;
1965 #endif
1966         } while (vm_can_run());
1967
1968         if ((r = qemu_debug_requested())) {
1969             vm_stop(r);
1970         }
1971         if (qemu_shutdown_requested()) {
1972             monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
1973             if (no_shutdown) {
1974                 vm_stop(0);
1975                 no_shutdown = 0;
1976             } else
1977                 break;
1978         }
1979         if (qemu_reset_requested()) {
1980             pause_all_vcpus();
1981             qemu_system_reset();
1982             resume_all_vcpus();
1983         }
1984         if (qemu_powerdown_requested()) {
1985             monitor_protocol_event(QEVENT_POWERDOWN, NULL);
1986             qemu_irq_raise(qemu_system_powerdown);
1987         }
1988         if ((r = qemu_vmstop_requested())) {
1989             vm_stop(r);
1990         }
1991     }
1992     pause_all_vcpus();
1993 }
1994
1995 static void version(void)
1996 {
1997     printf("QEMU emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
1998 }
1999
2000 static void help(int exitcode)
2001 {
2002     const char *options_help =
2003 #define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \
2004         opt_help
2005 #define DEFHEADING(text) stringify(text) "\n"
2006 #include "qemu-options.h"
2007 #undef DEF
2008 #undef DEFHEADING
2009 #undef GEN_DOCS
2010         ;
2011     version();
2012     printf("usage: %s [options] [disk_image]\n"
2013            "\n"
2014            "'disk_image' is a raw hard disk image for IDE hard disk 0\n"
2015            "\n"
2016            "%s\n"
2017            "During emulation, the following keys are useful:\n"
2018            "ctrl-alt-f      toggle full screen\n"
2019            "ctrl-alt-n      switch to virtual console 'n'\n"
2020            "ctrl-alt        toggle mouse and keyboard grab\n"
2021            "\n"
2022            "When using -nographic, press 'ctrl-a h' to get some help.\n",
2023            "qemu",
2024            options_help);
2025     exit(exitcode);
2026 }
2027
2028 #define HAS_ARG 0x0001
2029
2030 enum {
2031 #define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \
2032     opt_enum,
2033 #define DEFHEADING(text)
2034 #include "qemu-options.h"
2035 #undef DEF
2036 #undef DEFHEADING
2037 #undef GEN_DOCS
2038 };
2039
2040 typedef struct QEMUOption {
2041     const char *name;
2042     int flags;
2043     int index;
2044     uint32_t arch_mask;
2045 } QEMUOption;
2046
2047 static const QEMUOption qemu_options[] = {
2048     { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
2049 #define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \
2050     { option, opt_arg, opt_enum, arch_mask },
2051 #define DEFHEADING(text)
2052 #include "qemu-options.h"
2053 #undef DEF
2054 #undef DEFHEADING
2055 #undef GEN_DOCS
2056     { NULL },
2057 };
2058 static void select_vgahw (const char *p)
2059 {
2060     const char *opts;
2061
2062     default_vga = 0;
2063     vga_interface_type = VGA_NONE;
2064     if (strstart(p, "std", &opts)) {
2065         vga_interface_type = VGA_STD;
2066     } else if (strstart(p, "cirrus", &opts)) {
2067         vga_interface_type = VGA_CIRRUS;
2068     } else if (strstart(p, "vmware", &opts)) {
2069         vga_interface_type = VGA_VMWARE;
2070     } else if (strstart(p, "xenfb", &opts)) {
2071         vga_interface_type = VGA_XENFB;
2072     } else if (!strstart(p, "none", &opts)) {
2073     invalid_vga:
2074         fprintf(stderr, "Unknown vga type: %s\n", p);
2075         exit(1);
2076     }
2077     while (*opts) {
2078         const char *nextopt;
2079
2080         if (strstart(opts, ",retrace=", &nextopt)) {
2081             opts = nextopt;
2082             if (strstart(opts, "dumb", &nextopt))
2083                 vga_retrace_method = VGA_RETRACE_DUMB;
2084             else if (strstart(opts, "precise", &nextopt))
2085                 vga_retrace_method = VGA_RETRACE_PRECISE;
2086             else goto invalid_vga;
2087         } else goto invalid_vga;
2088         opts = nextopt;
2089     }
2090 }
2091
2092 static int balloon_parse(const char *arg)
2093 {
2094     QemuOpts *opts;
2095
2096     if (strcmp(arg, "none") == 0) {
2097         return 0;
2098     }
2099
2100     if (!strncmp(arg, "virtio", 6)) {
2101         if (arg[6] == ',') {
2102             /* have params -> parse them */
2103             opts = qemu_opts_parse(&qemu_device_opts, arg+7, 0);
2104             if (!opts)
2105                 return  -1;
2106         } else {
2107             /* create empty opts */
2108             opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
2109         }
2110         qemu_opt_set(opts, "driver", "virtio-balloon-pci");
2111         return 0;
2112     }
2113
2114     return -1;
2115 }
2116
2117 #ifdef _WIN32
2118 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
2119 {
2120     exit(STATUS_CONTROL_C_EXIT);
2121     return TRUE;
2122 }
2123 #endif
2124
2125 #ifndef _WIN32
2126
2127 static void termsig_handler(int signal)
2128 {
2129     qemu_system_shutdown_request();
2130 }
2131
2132 static void sigchld_handler(int signal)
2133 {
2134     waitpid(-1, NULL, WNOHANG);
2135 }
2136
2137 static void sighandler_setup(void)
2138 {
2139     struct sigaction act;
2140
2141     memset(&act, 0, sizeof(act));
2142     act.sa_handler = termsig_handler;
2143     sigaction(SIGINT,  &act, NULL);
2144     sigaction(SIGHUP,  &act, NULL);
2145     sigaction(SIGTERM, &act, NULL);
2146
2147     act.sa_handler = sigchld_handler;
2148     act.sa_flags = SA_NOCLDSTOP;
2149     sigaction(SIGCHLD, &act, NULL);
2150 }
2151
2152 #endif
2153
2154 #ifdef _WIN32
2155 /* Look for support files in the same directory as the executable.  */
2156 static char *find_datadir(const char *argv0)
2157 {
2158     char *p;
2159     char buf[MAX_PATH];
2160     DWORD len;
2161
2162     len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
2163     if (len == 0) {
2164         return NULL;
2165     }
2166
2167     buf[len] = 0;
2168     p = buf + len - 1;
2169     while (p != buf && *p != '\\')
2170         p--;
2171     *p = 0;
2172     if (access(buf, R_OK) == 0) {
2173         return qemu_strdup(buf);
2174     }
2175     return NULL;
2176 }
2177 #else /* !_WIN32 */
2178
2179 /* Find a likely location for support files using the location of the binary.
2180    For installed binaries this will be "$bindir/../share/qemu".  When
2181    running from the build tree this will be "$bindir/../pc-bios".  */
2182 #define SHARE_SUFFIX "/share/qemu"
2183 #define BUILD_SUFFIX "/pc-bios"
2184 static char *find_datadir(const char *argv0)
2185 {
2186     char *dir;
2187     char *p = NULL;
2188     char *res;
2189     char buf[PATH_MAX];
2190     size_t max_len;
2191
2192 #if defined(__linux__)
2193     {
2194         int len;
2195         len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
2196         if (len > 0) {
2197             buf[len] = 0;
2198             p = buf;
2199         }
2200     }
2201 #elif defined(__FreeBSD__)
2202     {
2203         static int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
2204         size_t len = sizeof(buf) - 1;
2205
2206         *buf = '\0';
2207         if (!sysctl(mib, sizeof(mib)/sizeof(*mib), buf, &len, NULL, 0) &&
2208             *buf) {
2209             buf[sizeof(buf) - 1] = '\0';
2210             p = buf;
2211         }
2212     }
2213 #endif
2214     /* If we don't have any way of figuring out the actual executable
2215        location then try argv[0].  */
2216     if (!p) {
2217         p = realpath(argv0, buf);
2218         if (!p) {
2219             return NULL;
2220         }
2221     }
2222     dir = dirname(p);
2223     dir = dirname(dir);
2224
2225     max_len = strlen(dir) +
2226         MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
2227     res = qemu_mallocz(max_len);
2228     snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
2229     if (access(res, R_OK)) {
2230         snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
2231         if (access(res, R_OK)) {
2232             qemu_free(res);
2233             res = NULL;
2234         }
2235     }
2236
2237     return res;
2238 }
2239 #undef SHARE_SUFFIX
2240 #undef BUILD_SUFFIX
2241 #endif
2242
2243 char *qemu_find_file(int type, const char *name)
2244 {
2245     int len;
2246     const char *subdir;
2247     char *buf;
2248
2249     /* If name contains path separators then try it as a straight path.  */
2250     if ((strchr(name, '/') || strchr(name, '\\'))
2251         && access(name, R_OK) == 0) {
2252         return qemu_strdup(name);
2253     }
2254     switch (type) {
2255     case QEMU_FILE_TYPE_BIOS:
2256         subdir = "";
2257         break;
2258     case QEMU_FILE_TYPE_KEYMAP:
2259         subdir = "keymaps/";
2260         break;
2261     default:
2262         abort();
2263     }
2264     len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
2265     buf = qemu_mallocz(len);
2266     snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
2267     if (access(buf, R_OK)) {
2268         qemu_free(buf);
2269         return NULL;
2270     }
2271     return buf;
2272 }
2273
2274 static int device_help_func(QemuOpts *opts, void *opaque)
2275 {
2276     return qdev_device_help(opts);
2277 }
2278
2279 static int device_init_func(QemuOpts *opts, void *opaque)
2280 {
2281     DeviceState *dev;
2282
2283     dev = qdev_device_add(opts);
2284     if (!dev)
2285         return -1;
2286     return 0;
2287 }
2288
2289 static int chardev_init_func(QemuOpts *opts, void *opaque)
2290 {
2291     CharDriverState *chr;
2292
2293     chr = qemu_chr_open_opts(opts, NULL);
2294     if (!chr)
2295         return -1;
2296     return 0;
2297 }
2298
2299 #ifdef CONFIG_LINUX
2300 static int fsdev_init_func(QemuOpts *opts, void *opaque)
2301 {
2302     int ret;
2303     ret = qemu_fsdev_add(opts);
2304
2305     return ret;
2306 }
2307 #endif
2308
2309 static int mon_init_func(QemuOpts *opts, void *opaque)
2310 {
2311     CharDriverState *chr;
2312     const char *chardev;
2313     const char *mode;
2314     int flags;
2315
2316     mode = qemu_opt_get(opts, "mode");
2317     if (mode == NULL) {
2318         mode = "readline";
2319     }
2320     if (strcmp(mode, "readline") == 0) {
2321         flags = MONITOR_USE_READLINE;
2322     } else if (strcmp(mode, "control") == 0) {
2323         flags = MONITOR_USE_CONTROL;
2324     } else {
2325         fprintf(stderr, "unknown monitor mode \"%s\"\n", mode);
2326         exit(1);
2327     }
2328
2329     if (qemu_opt_get_bool(opts, "default", 0))
2330         flags |= MONITOR_IS_DEFAULT;
2331
2332     chardev = qemu_opt_get(opts, "chardev");
2333     chr = qemu_chr_find(chardev);
2334     if (chr == NULL) {
2335         fprintf(stderr, "chardev \"%s\" not found\n", chardev);
2336         exit(1);
2337     }
2338
2339     monitor_init(chr, flags);
2340     return 0;
2341 }
2342
2343 static void monitor_parse(const char *optarg, const char *mode)
2344 {
2345     static int monitor_device_index = 0;
2346     QemuOpts *opts;
2347     const char *p;
2348     char label[32];
2349     int def = 0;
2350
2351     if (strstart(optarg, "chardev:", &p)) {
2352         snprintf(label, sizeof(label), "%s", p);
2353     } else {
2354         snprintf(label, sizeof(label), "compat_monitor%d",
2355                  monitor_device_index);
2356         if (monitor_device_index == 0) {
2357             def = 1;
2358         }
2359         opts = qemu_chr_parse_compat(label, optarg);
2360         if (!opts) {
2361             fprintf(stderr, "parse error: %s\n", optarg);
2362             exit(1);
2363         }
2364     }
2365
2366     opts = qemu_opts_create(&qemu_mon_opts, label, 1);
2367     if (!opts) {
2368         fprintf(stderr, "duplicate chardev: %s\n", label);
2369         exit(1);
2370     }
2371     qemu_opt_set(opts, "mode", mode);
2372     qemu_opt_set(opts, "chardev", label);
2373     if (def)
2374         qemu_opt_set(opts, "default", "on");
2375     monitor_device_index++;
2376 }
2377
2378 struct device_config {
2379     enum {
2380         DEV_USB,       /* -usbdevice     */
2381         DEV_BT,        /* -bt            */
2382         DEV_SERIAL,    /* -serial        */
2383         DEV_PARALLEL,  /* -parallel      */
2384         DEV_VIRTCON,   /* -virtioconsole */
2385         DEV_DEBUGCON,  /* -debugcon */
2386     } type;
2387     const char *cmdline;
2388     QTAILQ_ENTRY(device_config) next;
2389 };
2390 QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
2391
2392 static void add_device_config(int type, const char *cmdline)
2393 {
2394     struct device_config *conf;
2395
2396     conf = qemu_mallocz(sizeof(*conf));
2397     conf->type = type;
2398     conf->cmdline = cmdline;
2399     QTAILQ_INSERT_TAIL(&device_configs, conf, next);
2400 }
2401
2402 static int foreach_device_config(int type, int (*func)(const char *cmdline))
2403 {
2404     struct device_config *conf;
2405     int rc;
2406
2407     QTAILQ_FOREACH(conf, &device_configs, next) {
2408         if (conf->type != type)
2409             continue;
2410         rc = func(conf->cmdline);
2411         if (0 != rc)
2412             return rc;
2413     }
2414     return 0;
2415 }
2416
2417 static int serial_parse(const char *devname)
2418 {
2419     static int index = 0;
2420     char label[32];
2421
2422     if (strcmp(devname, "none") == 0)
2423         return 0;
2424     if (index == MAX_SERIAL_PORTS) {
2425         fprintf(stderr, "qemu: too many serial ports\n");
2426         exit(1);
2427     }
2428     snprintf(label, sizeof(label), "serial%d", index);
2429     serial_hds[index] = qemu_chr_open(label, devname, NULL);
2430     if (!serial_hds[index]) {
2431         fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
2432                 devname, strerror(errno));
2433         return -1;
2434     }
2435     index++;
2436     return 0;
2437 }
2438
2439 static int parallel_parse(const char *devname)
2440 {
2441     static int index = 0;
2442     char label[32];
2443
2444     if (strcmp(devname, "none") == 0)
2445         return 0;
2446     if (index == MAX_PARALLEL_PORTS) {
2447         fprintf(stderr, "qemu: too many parallel ports\n");
2448         exit(1);
2449     }
2450     snprintf(label, sizeof(label), "parallel%d", index);
2451     parallel_hds[index] = qemu_chr_open(label, devname, NULL);
2452     if (!parallel_hds[index]) {
2453         fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
2454                 devname, strerror(errno));
2455         return -1;
2456     }
2457     index++;
2458     return 0;
2459 }
2460
2461 static int virtcon_parse(const char *devname)
2462 {
2463     static int index = 0;
2464     char label[32];
2465     QemuOpts *bus_opts, *dev_opts;
2466
2467     if (strcmp(devname, "none") == 0)
2468         return 0;
2469     if (index == MAX_VIRTIO_CONSOLES) {
2470         fprintf(stderr, "qemu: too many virtio consoles\n");
2471         exit(1);
2472     }
2473
2474     bus_opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
2475     qemu_opt_set(bus_opts, "driver", "virtio-serial");
2476
2477     dev_opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
2478     qemu_opt_set(dev_opts, "driver", "virtconsole");
2479
2480     snprintf(label, sizeof(label), "virtcon%d", index);
2481     virtcon_hds[index] = qemu_chr_open(label, devname, NULL);
2482     if (!virtcon_hds[index]) {
2483         fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
2484                 devname, strerror(errno));
2485         return -1;
2486     }
2487     qemu_opt_set(dev_opts, "chardev", label);
2488
2489     index++;
2490     return 0;
2491 }
2492
2493 static int debugcon_parse(const char *devname)
2494 {
2495     QemuOpts *opts;
2496
2497     if (!qemu_chr_open("debugcon", devname, NULL)) {
2498         exit(1);
2499     }
2500     opts = qemu_opts_create(&qemu_device_opts, "debugcon", 1);
2501     if (!opts) {
2502         fprintf(stderr, "qemu: already have a debugcon device\n");
2503         exit(1);
2504     }
2505     qemu_opt_set(opts, "driver", "isa-debugcon");
2506     qemu_opt_set(opts, "chardev", "debugcon");
2507     return 0;
2508 }
2509
2510 static const QEMUOption *lookup_opt(int argc, char **argv,
2511                                     const char **poptarg, int *poptind)
2512 {
2513     const QEMUOption *popt;
2514     int optind = *poptind;
2515     char *r = argv[optind];
2516     const char *optarg;
2517
2518     loc_set_cmdline(argv, optind, 1);
2519     optind++;
2520     /* Treat --foo the same as -foo.  */
2521     if (r[1] == '-')
2522         r++;
2523     popt = qemu_options;
2524     for(;;) {
2525         if (!popt->name) {
2526             error_report("invalid option");
2527             exit(1);
2528         }
2529         if (!strcmp(popt->name, r + 1))
2530             break;
2531         popt++;
2532     }
2533     if (popt->flags & HAS_ARG) {
2534         if (optind >= argc) {
2535             error_report("requires an argument");
2536             exit(1);
2537         }
2538         optarg = argv[optind++];
2539         loc_set_cmdline(argv, optind - 2, 2);
2540     } else {
2541         optarg = NULL;
2542     }
2543
2544     *poptarg = optarg;
2545     *poptind = optind;
2546
2547     return popt;
2548 }
2549
2550 int main(int argc, char **argv, char **envp)
2551 {
2552     const char *gdbstub_dev = NULL;
2553     int i;
2554     int snapshot, linux_boot;
2555     const char *icount_option = NULL;
2556     const char *initrd_filename;
2557     const char *kernel_filename, *kernel_cmdline;
2558     char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
2559     DisplayState *ds;
2560     DisplayChangeListener *dcl;
2561     int cyls, heads, secs, translation;
2562     QemuOpts *hda_opts = NULL, *opts;
2563     int optind;
2564     const char *optarg;
2565     const char *loadvm = NULL;
2566     QEMUMachine *machine;
2567     const char *cpu_model;
2568 #ifndef _WIN32
2569     int fds[2];
2570 #endif
2571     int tb_size;
2572     const char *pid_file = NULL;
2573     const char *incoming = NULL;
2574 #ifndef _WIN32
2575     int fd = 0;
2576     struct passwd *pwd = NULL;
2577     const char *chroot_dir = NULL;
2578     const char *run_as = NULL;
2579 #endif
2580     int show_vnc_port = 0;
2581     int defconfig = 1;
2582
2583     error_set_progname(argv[0]);
2584
2585     init_clocks();
2586
2587     qemu_cache_utils_init(envp);
2588
2589     QLIST_INIT (&vm_change_state_head);
2590 #ifndef _WIN32
2591     {
2592         struct sigaction act;
2593         sigfillset(&act.sa_mask);
2594         act.sa_flags = 0;
2595         act.sa_handler = SIG_IGN;
2596         sigaction(SIGPIPE, &act, NULL);
2597     }
2598 #else
2599     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
2600     /* Note: cpu_interrupt() is currently not SMP safe, so we force
2601        QEMU to run on a single CPU */
2602     {
2603         HANDLE h;
2604         DWORD mask, smask;
2605         int i;
2606         h = GetCurrentProcess();
2607         if (GetProcessAffinityMask(h, &mask, &smask)) {
2608             for(i = 0; i < 32; i++) {
2609                 if (mask & (1 << i))
2610                     break;
2611             }
2612             if (i != 32) {
2613                 mask = 1 << i;
2614                 SetProcessAffinityMask(h, mask);
2615             }
2616         }
2617     }
2618 #endif
2619
2620     module_call_init(MODULE_INIT_MACHINE);
2621     machine = find_default_machine();
2622     cpu_model = NULL;
2623     initrd_filename = NULL;
2624     ram_size = 0;
2625     snapshot = 0;
2626     kernel_filename = NULL;
2627     kernel_cmdline = "";
2628     cyls = heads = secs = 0;
2629     translation = BIOS_ATA_TRANSLATION_AUTO;
2630
2631     for (i = 0; i < MAX_NODES; i++) {
2632         node_mem[i] = 0;
2633         node_cpumask[i] = 0;
2634     }
2635
2636     nb_numa_nodes = 0;
2637     nb_nics = 0;
2638
2639     tb_size = 0;
2640     autostart= 1;
2641
2642     /* first pass of option parsing */
2643     optind = 1;
2644     while (optind < argc) {
2645         if (argv[optind][0] != '-') {
2646             /* disk image */
2647             optind++;
2648             continue;
2649         } else {
2650             const QEMUOption *popt;
2651
2652             popt = lookup_opt(argc, argv, &optarg, &optind);
2653             switch (popt->index) {
2654             case QEMU_OPTION_nodefconfig:
2655                 defconfig=0;
2656                 break;
2657             }
2658         }
2659     }
2660
2661     if (defconfig) {
2662         int ret;
2663
2664         ret = qemu_read_config_file(CONFIG_QEMU_CONFDIR "/qemu.conf");
2665         if (ret == -EINVAL) {
2666             exit(1);
2667         }
2668
2669         ret = qemu_read_config_file(arch_config_name);
2670         if (ret == -EINVAL) {
2671             exit(1);
2672         }
2673     }
2674     cpudef_init();
2675
2676     /* second pass of option parsing */
2677     optind = 1;
2678     for(;;) {
2679         if (optind >= argc)
2680             break;
2681         if (argv[optind][0] != '-') {
2682             hda_opts = drive_add(argv[optind++], HD_ALIAS, 0);
2683         } else {
2684             const QEMUOption *popt;
2685
2686             popt = lookup_opt(argc, argv, &optarg, &optind);
2687             if (!(popt->arch_mask & arch_type)) {
2688                 printf("Option %s not supported for this target\n", popt->name);
2689                 exit(1);
2690             }
2691             switch(popt->index) {
2692             case QEMU_OPTION_M:
2693                 machine = find_machine(optarg);
2694                 if (!machine) {
2695                     QEMUMachine *m;
2696                     printf("Supported machines are:\n");
2697                     for(m = first_machine; m != NULL; m = m->next) {
2698                         if (m->alias)
2699                             printf("%-10s %s (alias of %s)\n",
2700                                    m->alias, m->desc, m->name);
2701                         printf("%-10s %s%s\n",
2702                                m->name, m->desc,
2703                                m->is_default ? " (default)" : "");
2704                     }
2705                     exit(*optarg != '?');
2706                 }
2707                 break;
2708             case QEMU_OPTION_cpu:
2709                 /* hw initialization will check this */
2710                 if (*optarg == '?') {
2711                     list_cpus(stdout, &fprintf, optarg);
2712                     exit(0);
2713                 } else {
2714                     cpu_model = optarg;
2715                 }
2716                 break;
2717             case QEMU_OPTION_initrd:
2718                 initrd_filename = optarg;
2719                 break;
2720             case QEMU_OPTION_hda:
2721                 if (cyls == 0)
2722                     hda_opts = drive_add(optarg, HD_ALIAS, 0);
2723                 else
2724                     hda_opts = drive_add(optarg, HD_ALIAS
2725                              ",cyls=%d,heads=%d,secs=%d%s",
2726                              0, cyls, heads, secs,
2727                              translation == BIOS_ATA_TRANSLATION_LBA ?
2728                                  ",trans=lba" :
2729                              translation == BIOS_ATA_TRANSLATION_NONE ?
2730                                  ",trans=none" : "");
2731                  break;
2732             case QEMU_OPTION_hdb:
2733             case QEMU_OPTION_hdc:
2734             case QEMU_OPTION_hdd:
2735                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
2736                 break;
2737             case QEMU_OPTION_drive:
2738                 drive_add(NULL, "%s", optarg);
2739                 break;
2740             case QEMU_OPTION_set:
2741                 if (qemu_set_option(optarg) != 0)
2742                     exit(1);
2743                 break;
2744             case QEMU_OPTION_global:
2745                 if (qemu_global_option(optarg) != 0)
2746                     exit(1);
2747                 break;
2748             case QEMU_OPTION_mtdblock:
2749                 drive_add(optarg, MTD_ALIAS);
2750                 break;
2751             case QEMU_OPTION_sd:
2752                 drive_add(optarg, SD_ALIAS);
2753                 break;
2754             case QEMU_OPTION_pflash:
2755                 drive_add(optarg, PFLASH_ALIAS);
2756                 break;
2757             case QEMU_OPTION_snapshot:
2758                 snapshot = 1;
2759                 break;
2760             case QEMU_OPTION_hdachs:
2761                 {
2762                     const char *p;
2763                     p = optarg;
2764                     cyls = strtol(p, (char **)&p, 0);
2765                     if (cyls < 1 || cyls > 16383)
2766                         goto chs_fail;
2767                     if (*p != ',')
2768                         goto chs_fail;
2769                     p++;
2770                     heads = strtol(p, (char **)&p, 0);
2771                     if (heads < 1 || heads > 16)
2772                         goto chs_fail;
2773                     if (*p != ',')
2774                         goto chs_fail;
2775                     p++;
2776                     secs = strtol(p, (char **)&p, 0);
2777                     if (secs < 1 || secs > 63)
2778                         goto chs_fail;
2779                     if (*p == ',') {
2780                         p++;
2781                         if (!strcmp(p, "none"))
2782                             translation = BIOS_ATA_TRANSLATION_NONE;
2783                         else if (!strcmp(p, "lba"))
2784                             translation = BIOS_ATA_TRANSLATION_LBA;
2785                         else if (!strcmp(p, "auto"))
2786                             translation = BIOS_ATA_TRANSLATION_AUTO;
2787                         else
2788                             goto chs_fail;
2789                     } else if (*p != '\0') {
2790                     chs_fail:
2791                         fprintf(stderr, "qemu: invalid physical CHS format\n");
2792                         exit(1);
2793                     }
2794                     if (hda_opts != NULL) {
2795                         char num[16];
2796                         snprintf(num, sizeof(num), "%d", cyls);
2797                         qemu_opt_set(hda_opts, "cyls", num);
2798                         snprintf(num, sizeof(num), "%d", heads);
2799                         qemu_opt_set(hda_opts, "heads", num);
2800                         snprintf(num, sizeof(num), "%d", secs);
2801                         qemu_opt_set(hda_opts, "secs", num);
2802                         if (translation == BIOS_ATA_TRANSLATION_LBA)
2803                             qemu_opt_set(hda_opts, "trans", "lba");
2804                         if (translation == BIOS_ATA_TRANSLATION_NONE)
2805                             qemu_opt_set(hda_opts, "trans", "none");
2806                     }
2807                 }
2808                 break;
2809             case QEMU_OPTION_numa:
2810                 if (nb_numa_nodes >= MAX_NODES) {
2811                     fprintf(stderr, "qemu: too many NUMA nodes\n");
2812                     exit(1);
2813                 }
2814                 numa_add(optarg);
2815                 break;
2816             case QEMU_OPTION_nographic:
2817                 display_type = DT_NOGRAPHIC;
2818                 break;
2819 #ifdef CONFIG_CURSES
2820             case QEMU_OPTION_curses:
2821                 display_type = DT_CURSES;
2822                 break;
2823 #endif
2824             case QEMU_OPTION_portrait:
2825                 graphic_rotate = 1;
2826                 break;
2827             case QEMU_OPTION_kernel:
2828                 kernel_filename = optarg;
2829                 break;
2830             case QEMU_OPTION_append:
2831                 kernel_cmdline = optarg;
2832                 break;
2833             case QEMU_OPTION_cdrom:
2834                 drive_add(optarg, CDROM_ALIAS);
2835                 break;
2836             case QEMU_OPTION_boot:
2837                 {
2838                     static const char * const params[] = {
2839                         "order", "once", "menu", NULL
2840                     };
2841                     char buf[sizeof(boot_devices)];
2842                     char *standard_boot_devices;
2843                     int legacy = 0;
2844
2845                     if (!strchr(optarg, '=')) {
2846                         legacy = 1;
2847                         pstrcpy(buf, sizeof(buf), optarg);
2848                     } else if (check_params(buf, sizeof(buf), params, optarg) < 0) {
2849                         fprintf(stderr,
2850                                 "qemu: unknown boot parameter '%s' in '%s'\n",
2851                                 buf, optarg);
2852                         exit(1);
2853                     }
2854
2855                     if (legacy ||
2856                         get_param_value(buf, sizeof(buf), "order", optarg)) {
2857                         validate_bootdevices(buf);
2858                         pstrcpy(boot_devices, sizeof(boot_devices), buf);
2859                     }
2860                     if (!legacy) {
2861                         if (get_param_value(buf, sizeof(buf),
2862                                             "once", optarg)) {
2863                             validate_bootdevices(buf);
2864                             standard_boot_devices = qemu_strdup(boot_devices);
2865                             pstrcpy(boot_devices, sizeof(boot_devices), buf);
2866                             qemu_register_reset(restore_boot_devices,
2867                                                 standard_boot_devices);
2868                         }
2869                         if (get_param_value(buf, sizeof(buf),
2870                                             "menu", optarg)) {
2871                             if (!strcmp(buf, "on")) {
2872                                 boot_menu = 1;
2873                             } else if (!strcmp(buf, "off")) {
2874                                 boot_menu = 0;
2875                             } else {
2876                                 fprintf(stderr,
2877                                         "qemu: invalid option value '%s'\n",
2878                                         buf);
2879                                 exit(1);
2880                             }
2881                         }
2882                     }
2883                 }
2884                 break;
2885             case QEMU_OPTION_fda:
2886             case QEMU_OPTION_fdb:
2887                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
2888                 break;
2889             case QEMU_OPTION_no_fd_bootchk:
2890                 fd_bootchk = 0;
2891                 break;
2892             case QEMU_OPTION_netdev:
2893                 if (net_client_parse(&qemu_netdev_opts, optarg) == -1) {
2894                     exit(1);
2895                 }
2896                 break;
2897             case QEMU_OPTION_net:
2898                 if (net_client_parse(&qemu_net_opts, optarg) == -1) {
2899                     exit(1);
2900                 }
2901                 break;
2902 #ifdef CONFIG_SLIRP
2903             case QEMU_OPTION_tftp:
2904                 legacy_tftp_prefix = optarg;
2905                 break;
2906             case QEMU_OPTION_bootp:
2907                 legacy_bootp_filename = optarg;
2908                 break;
2909 #ifndef _WIN32
2910             case QEMU_OPTION_smb:
2911                 if (net_slirp_smb(optarg) < 0)
2912                     exit(1);
2913                 break;
2914 #endif
2915             case QEMU_OPTION_redir:
2916                 if (net_slirp_redir(optarg) < 0)
2917                     exit(1);
2918                 break;
2919 #endif
2920             case QEMU_OPTION_bt:
2921                 add_device_config(DEV_BT, optarg);
2922                 break;
2923             case QEMU_OPTION_audio_help:
2924                 if (!(audio_available())) {
2925                     printf("Option %s not supported for this target\n", popt->name);
2926                     exit(1);
2927                 }
2928                 AUD_help ();
2929                 exit (0);
2930                 break;
2931             case QEMU_OPTION_soundhw:
2932                 if (!(audio_available())) {
2933                     printf("Option %s not supported for this target\n", popt->name);
2934                     exit(1);
2935                 }
2936                 select_soundhw (optarg);
2937                 break;
2938             case QEMU_OPTION_h:
2939                 help(0);
2940                 break;
2941             case QEMU_OPTION_version:
2942                 version();
2943                 exit(0);
2944                 break;
2945             case QEMU_OPTION_m: {
2946                 uint64_t value;
2947                 char *ptr;
2948
2949                 value = strtoul(optarg, &ptr, 10);
2950                 switch (*ptr) {
2951                 case 0: case 'M': case 'm':
2952                     value <<= 20;
2953                     break;
2954                 case 'G': case 'g':
2955                     value <<= 30;
2956                     break;
2957                 default:
2958                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
2959                     exit(1);
2960                 }
2961
2962                 /* On 32-bit hosts, QEMU is limited by virtual address space */
2963                 if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
2964                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
2965                     exit(1);
2966                 }
2967                 if (value != (uint64_t)(ram_addr_t)value) {
2968                     fprintf(stderr, "qemu: ram size too large\n");
2969                     exit(1);
2970                 }
2971                 ram_size = value;
2972                 break;
2973             }
2974             case QEMU_OPTION_mempath:
2975                 mem_path = optarg;
2976                 break;
2977 #ifdef MAP_POPULATE
2978             case QEMU_OPTION_mem_prealloc:
2979                 mem_prealloc = 1;
2980                 break;
2981 #endif
2982             case QEMU_OPTION_d:
2983                 set_cpu_log(optarg);
2984                 break;
2985             case QEMU_OPTION_s:
2986                 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
2987                 break;
2988             case QEMU_OPTION_gdb:
2989                 gdbstub_dev = optarg;
2990                 break;
2991             case QEMU_OPTION_L:
2992                 data_dir = optarg;
2993                 break;
2994             case QEMU_OPTION_bios:
2995                 bios_name = optarg;
2996                 break;
2997             case QEMU_OPTION_singlestep:
2998                 singlestep = 1;
2999                 break;
3000             case QEMU_OPTION_S:
3001                 autostart = 0;
3002                 break;
3003             case QEMU_OPTION_k:
3004                 keyboard_layout = optarg;
3005                 break;
3006             case QEMU_OPTION_localtime:
3007                 rtc_utc = 0;
3008                 break;
3009             case QEMU_OPTION_vga:
3010                 select_vgahw (optarg);
3011                 break;
3012             case QEMU_OPTION_g:
3013                 {
3014                     const char *p;
3015                     int w, h, depth;
3016                     p = optarg;
3017                     w = strtol(p, (char **)&p, 10);
3018                     if (w <= 0) {
3019                     graphic_error:
3020                         fprintf(stderr, "qemu: invalid resolution or depth\n");
3021                         exit(1);
3022                     }
3023                     if (*p != 'x')
3024                         goto graphic_error;
3025                     p++;
3026                     h = strtol(p, (char **)&p, 10);
3027                     if (h <= 0)
3028                         goto graphic_error;
3029                     if (*p == 'x') {
3030                         p++;
3031                         depth = strtol(p, (char **)&p, 10);
3032                         if (depth != 8 && depth != 15 && depth != 16 &&
3033                             depth != 24 && depth != 32)
3034                             goto graphic_error;
3035                     } else if (*p == '\0') {
3036                         depth = graphic_depth;
3037                     } else {
3038                         goto graphic_error;
3039                     }
3040
3041                     graphic_width = w;
3042                     graphic_height = h;
3043                     graphic_depth = depth;
3044                 }
3045                 break;
3046             case QEMU_OPTION_echr:
3047                 {
3048                     char *r;
3049                     term_escape_char = strtol(optarg, &r, 0);
3050                     if (r == optarg)
3051                         printf("Bad argument to echr\n");
3052                     break;
3053                 }
3054             case QEMU_OPTION_monitor:
3055                 monitor_parse(optarg, "readline");
3056                 default_monitor = 0;
3057                 break;
3058             case QEMU_OPTION_qmp:
3059                 monitor_parse(optarg, "control");
3060                 default_monitor = 0;
3061                 break;
3062             case QEMU_OPTION_mon:
3063                 opts = qemu_opts_parse(&qemu_mon_opts, optarg, 1);
3064                 if (!opts) {
3065                     exit(1);
3066                 }
3067                 default_monitor = 0;
3068                 break;
3069             case QEMU_OPTION_chardev:
3070                 opts = qemu_opts_parse(&qemu_chardev_opts, optarg, 1);
3071                 if (!opts) {
3072                     exit(1);
3073                 }
3074                 break;
3075 #ifdef CONFIG_LINUX
3076             case QEMU_OPTION_fsdev:
3077                 opts = qemu_opts_parse(&qemu_fsdev_opts, optarg, 1);
3078                 if (!opts) {
3079                     fprintf(stderr, "parse error: %s\n", optarg);
3080                     exit(1);
3081                 }
3082                 break;
3083             case QEMU_OPTION_virtfs: {
3084                 char *arg_fsdev = NULL;
3085                 char *arg_9p = NULL;
3086                 int len = 0;
3087
3088                 opts = qemu_opts_parse(&qemu_virtfs_opts, optarg, 1);
3089                 if (!opts) {
3090                     fprintf(stderr, "parse error: %s\n", optarg);
3091                     exit(1);
3092                 }
3093
3094                 len = strlen(",id=,path=");
3095                 len += strlen(qemu_opt_get(opts, "fstype"));
3096                 len += strlen(qemu_opt_get(opts, "mount_tag"));
3097                 len += strlen(qemu_opt_get(opts, "path"));
3098                 arg_fsdev = qemu_malloc((len + 1) * sizeof(*arg_fsdev));
3099
3100                 if (!arg_fsdev) {
3101                     fprintf(stderr, "No memory to parse -fsdev for %s\n",
3102                             optarg);
3103                     exit(1);
3104                 }
3105
3106                 sprintf(arg_fsdev, "%s,id=%s,path=%s",
3107                                 qemu_opt_get(opts, "fstype"),
3108                                 qemu_opt_get(opts, "mount_tag"),
3109                                 qemu_opt_get(opts, "path"));
3110
3111                 len = strlen("virtio-9p-pci,fsdev=,mount_tag=");
3112                 len += 2*strlen(qemu_opt_get(opts, "mount_tag"));
3113                 arg_9p = qemu_malloc((len + 1) * sizeof(*arg_9p));
3114
3115                 if (!arg_9p) {
3116                     fprintf(stderr, "No memory to parse -device for %s\n",
3117                             optarg);
3118                     exit(1);
3119                 }
3120
3121                 sprintf(arg_9p, "virtio-9p-pci,fsdev=%s,mount_tag=%s",
3122                                 qemu_opt_get(opts, "mount_tag"),
3123                                 qemu_opt_get(opts, "mount_tag"));
3124
3125                 if (!qemu_opts_parse(&qemu_fsdev_opts, arg_fsdev, 1)) {
3126                     fprintf(stderr, "parse error [fsdev]: %s\n", optarg);
3127                     exit(1);
3128                 }
3129
3130                 if (!qemu_opts_parse(&qemu_device_opts, arg_9p, 1)) {
3131                     fprintf(stderr, "parse error [device]: %s\n", optarg);
3132                     exit(1);
3133                 }
3134
3135                 qemu_free(arg_fsdev);
3136                 qemu_free(arg_9p);
3137                 break;
3138             }
3139 #endif
3140             case QEMU_OPTION_serial:
3141                 add_device_config(DEV_SERIAL, optarg);
3142                 default_serial = 0;
3143                 if (strncmp(optarg, "mon:", 4) == 0) {
3144                     default_monitor = 0;
3145                 }
3146                 break;
3147             case QEMU_OPTION_watchdog:
3148                 if (watchdog) {
3149                     fprintf(stderr,
3150                             "qemu: only one watchdog option may be given\n");
3151                     return 1;
3152                 }
3153                 watchdog = optarg;
3154                 break;
3155             case QEMU_OPTION_watchdog_action:
3156                 if (select_watchdog_action(optarg) == -1) {
3157                     fprintf(stderr, "Unknown -watchdog-action parameter\n");
3158                     exit(1);
3159                 }
3160                 break;
3161             case QEMU_OPTION_virtiocon:
3162                 add_device_config(DEV_VIRTCON, optarg);
3163                 default_virtcon = 0;
3164                 if (strncmp(optarg, "mon:", 4) == 0) {
3165                     default_monitor = 0;
3166                 }
3167                 break;
3168             case QEMU_OPTION_parallel:
3169                 add_device_config(DEV_PARALLEL, optarg);
3170                 default_parallel = 0;
3171                 if (strncmp(optarg, "mon:", 4) == 0) {
3172                     default_monitor = 0;
3173                 }
3174                 break;
3175             case QEMU_OPTION_debugcon:
3176                 add_device_config(DEV_DEBUGCON, optarg);
3177                 break;
3178             case QEMU_OPTION_loadvm:
3179                 loadvm = optarg;
3180                 break;
3181             case QEMU_OPTION_full_screen:
3182                 full_screen = 1;
3183                 break;
3184 #ifdef CONFIG_SDL
3185             case QEMU_OPTION_no_frame:
3186                 no_frame = 1;
3187                 break;
3188             case QEMU_OPTION_alt_grab:
3189                 alt_grab = 1;
3190                 break;
3191             case QEMU_OPTION_ctrl_grab:
3192                 ctrl_grab = 1;
3193                 break;
3194             case QEMU_OPTION_no_quit:
3195                 no_quit = 1;
3196                 break;
3197             case QEMU_OPTION_sdl:
3198                 display_type = DT_SDL;
3199                 break;
3200 #endif
3201             case QEMU_OPTION_pidfile:
3202                 pid_file = optarg;
3203                 break;
3204             case QEMU_OPTION_win2k_hack:
3205                 win2k_install_hack = 1;
3206                 break;
3207             case QEMU_OPTION_rtc_td_hack:
3208                 rtc_td_hack = 1;
3209                 break;
3210             case QEMU_OPTION_acpitable:
3211                 do_acpitable_option(optarg);
3212                 break;
3213             case QEMU_OPTION_smbios:
3214                 do_smbios_option(optarg);
3215                 break;
3216             case QEMU_OPTION_enable_kvm:
3217                 kvm_allowed = 1;
3218                 break;
3219             case QEMU_OPTION_usb:
3220                 usb_enabled = 1;
3221                 break;
3222             case QEMU_OPTION_usbdevice:
3223                 usb_enabled = 1;
3224                 add_device_config(DEV_USB, optarg);
3225                 break;
3226             case QEMU_OPTION_device:
3227                 if (!qemu_opts_parse(&qemu_device_opts, optarg, 1)) {
3228                     exit(1);
3229                 }
3230                 break;
3231             case QEMU_OPTION_smp:
3232                 smp_parse(optarg);
3233                 if (smp_cpus < 1) {
3234                     fprintf(stderr, "Invalid number of CPUs\n");
3235                     exit(1);
3236                 }
3237                 if (max_cpus < smp_cpus) {
3238                     fprintf(stderr, "maxcpus must be equal to or greater than "
3239                             "smp\n");
3240                     exit(1);
3241                 }
3242                 if (max_cpus > 255) {
3243                     fprintf(stderr, "Unsupported number of maxcpus\n");
3244                     exit(1);
3245                 }
3246                 break;
3247             case QEMU_OPTION_vnc:
3248                 display_type = DT_VNC;
3249                 vnc_display = optarg;
3250                 break;
3251             case QEMU_OPTION_no_acpi:
3252                 acpi_enabled = 0;
3253                 break;
3254             case QEMU_OPTION_no_hpet:
3255                 no_hpet = 1;
3256                 break;
3257             case QEMU_OPTION_balloon:
3258                 if (balloon_parse(optarg) < 0) {
3259                     fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
3260                     exit(1);
3261                 }
3262                 break;
3263             case QEMU_OPTION_no_reboot:
3264                 no_reboot = 1;
3265                 break;
3266             case QEMU_OPTION_no_shutdown:
3267                 no_shutdown = 1;
3268                 break;
3269             case QEMU_OPTION_show_cursor:
3270                 cursor_hide = 0;
3271                 break;
3272             case QEMU_OPTION_uuid:
3273                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
3274                     fprintf(stderr, "Fail to parse UUID string."
3275                             " Wrong format.\n");
3276                     exit(1);
3277                 }
3278                 break;
3279 #ifndef _WIN32
3280             case QEMU_OPTION_daemonize:
3281                 daemonize = 1;
3282                 break;
3283 #endif
3284             case QEMU_OPTION_option_rom:
3285                 if (nb_option_roms >= MAX_OPTION_ROMS) {
3286                     fprintf(stderr, "Too many option ROMs\n");
3287                     exit(1);
3288                 }
3289                 option_rom[nb_option_roms] = optarg;
3290                 nb_option_roms++;
3291                 break;
3292             case QEMU_OPTION_semihosting:
3293                 semihosting_enabled = 1;
3294                 break;
3295             case QEMU_OPTION_name:
3296                 qemu_name = qemu_strdup(optarg);
3297                  {
3298                      char *p = strchr(qemu_name, ',');
3299                      if (p != NULL) {
3300                         *p++ = 0;
3301                         if (strncmp(p, "process=", 8)) {
3302                             fprintf(stderr, "Unknown subargument %s to -name", p);
3303                             exit(1);
3304                         }
3305                         p += 8;
3306                         set_proc_name(p);
3307                      }
3308                  }
3309                 break;
3310             case QEMU_OPTION_prom_env:
3311                 if (nb_prom_envs >= MAX_PROM_ENVS) {
3312                     fprintf(stderr, "Too many prom variables\n");
3313                     exit(1);
3314                 }
3315                 prom_envs[nb_prom_envs] = optarg;
3316                 nb_prom_envs++;
3317                 break;
3318             case QEMU_OPTION_old_param:
3319                 old_param = 1;
3320                 break;
3321             case QEMU_OPTION_clock:
3322                 configure_alarms(optarg);
3323                 break;
3324             case QEMU_OPTION_startdate:
3325                 configure_rtc_date_offset(optarg, 1);
3326                 break;
3327             case QEMU_OPTION_rtc:
3328                 opts = qemu_opts_parse(&qemu_rtc_opts, optarg, 0);
3329                 if (!opts) {
3330                     exit(1);
3331                 }
3332                 configure_rtc(opts);
3333                 break;
3334             case QEMU_OPTION_tb_size:
3335                 tb_size = strtol(optarg, NULL, 0);
3336                 if (tb_size < 0)
3337                     tb_size = 0;
3338                 break;
3339             case QEMU_OPTION_icount:
3340                 icount_option = optarg;
3341                 break;
3342             case QEMU_OPTION_incoming:
3343                 incoming = optarg;
3344                 break;
3345             case QEMU_OPTION_nodefaults:
3346                 default_serial = 0;
3347                 default_parallel = 0;
3348                 default_virtcon = 0;
3349                 default_monitor = 0;
3350                 default_vga = 0;
3351                 default_net = 0;
3352                 default_floppy = 0;
3353                 default_cdrom = 0;
3354                 default_sdcard = 0;
3355                 break;
3356 #ifndef _WIN32
3357             case QEMU_OPTION_chroot:
3358                 chroot_dir = optarg;
3359                 break;
3360             case QEMU_OPTION_runas:
3361                 run_as = optarg;
3362                 break;
3363 #endif
3364             case QEMU_OPTION_xen_domid:
3365                 if (!(xen_available())) {
3366                     printf("Option %s not supported for this target\n", popt->name);
3367                     exit(1);
3368                 }
3369                 xen_domid = atoi(optarg);
3370                 break;
3371             case QEMU_OPTION_xen_create:
3372                 if (!(xen_available())) {
3373                     printf("Option %s not supported for this target\n", popt->name);
3374                     exit(1);
3375                 }
3376                 xen_mode = XEN_CREATE;
3377                 break;
3378             case QEMU_OPTION_xen_attach:
3379                 if (!(xen_available())) {
3380                     printf("Option %s not supported for this target\n", popt->name);
3381                     exit(1);
3382                 }
3383                 xen_mode = XEN_ATTACH;
3384                 break;
3385             case QEMU_OPTION_readconfig:
3386                 {
3387                     int ret = qemu_read_config_file(optarg);
3388                     if (ret < 0) {
3389                         fprintf(stderr, "read config %s: %s\n", optarg,
3390                             strerror(-ret));
3391                         exit(1);
3392                     }
3393                     break;
3394                 }
3395             case QEMU_OPTION_writeconfig:
3396                 {
3397                     FILE *fp;
3398                     if (strcmp(optarg, "-") == 0) {
3399                         fp = stdout;
3400                     } else {
3401                         fp = fopen(optarg, "w");
3402                         if (fp == NULL) {
3403                             fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
3404                             exit(1);
3405                         }
3406                     }
3407                     qemu_config_write(fp);
3408                     fclose(fp);
3409                     break;
3410                 }
3411             }
3412         }
3413     }
3414     loc_set_none();
3415
3416     /* If no data_dir is specified then try to find it relative to the
3417        executable path.  */
3418     if (!data_dir) {
3419         data_dir = find_datadir(argv[0]);
3420     }
3421     /* If all else fails use the install patch specified when building.  */
3422     if (!data_dir) {
3423         data_dir = CONFIG_QEMU_SHAREDIR;
3424     }
3425
3426     /*
3427      * Default to max_cpus = smp_cpus, in case the user doesn't
3428      * specify a max_cpus value.
3429      */
3430     if (!max_cpus)
3431         max_cpus = smp_cpus;
3432
3433     machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
3434     if (smp_cpus > machine->max_cpus) {
3435         fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
3436                 "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
3437                 machine->max_cpus);
3438         exit(1);
3439     }
3440
3441     qemu_opts_foreach(&qemu_device_opts, default_driver_check, NULL, 0);
3442     qemu_opts_foreach(&qemu_global_opts, default_driver_check, NULL, 0);
3443
3444     if (machine->no_serial) {
3445         default_serial = 0;
3446     }
3447     if (machine->no_parallel) {
3448         default_parallel = 0;
3449     }
3450     if (!machine->use_virtcon) {
3451         default_virtcon = 0;
3452     }
3453     if (machine->no_vga) {
3454         default_vga = 0;
3455     }
3456     if (machine->no_floppy) {
3457         default_floppy = 0;
3458     }
3459     if (machine->no_cdrom) {
3460         default_cdrom = 0;
3461     }
3462     if (machine->no_sdcard) {
3463         default_sdcard = 0;
3464     }
3465
3466     if (display_type == DT_NOGRAPHIC) {
3467         if (default_parallel)
3468             add_device_config(DEV_PARALLEL, "null");
3469         if (default_serial && default_monitor) {
3470             add_device_config(DEV_SERIAL, "mon:stdio");
3471         } else if (default_virtcon && default_monitor) {
3472             add_device_config(DEV_VIRTCON, "mon:stdio");
3473         } else {
3474             if (default_serial)
3475                 add_device_config(DEV_SERIAL, "stdio");
3476             if (default_virtcon)
3477                 add_device_config(DEV_VIRTCON, "stdio");
3478             if (default_monitor)
3479                 monitor_parse("stdio", "readline");
3480         }
3481     } else {
3482         if (default_serial)
3483             add_device_config(DEV_SERIAL, "vc:80Cx24C");
3484         if (default_parallel)
3485             add_device_config(DEV_PARALLEL, "vc:80Cx24C");
3486         if (default_monitor)
3487             monitor_parse("vc:80Cx24C", "readline");
3488         if (default_virtcon)
3489             add_device_config(DEV_VIRTCON, "vc:80Cx24C");
3490     }
3491     if (default_vga)
3492         vga_interface_type = VGA_CIRRUS;
3493
3494     socket_init();
3495
3496     if (qemu_opts_foreach(&qemu_chardev_opts, chardev_init_func, NULL, 1) != 0)
3497         exit(1);
3498 #ifdef CONFIG_LINUX
3499     if (qemu_opts_foreach(&qemu_fsdev_opts, fsdev_init_func, NULL, 1) != 0) {
3500         exit(1);
3501     }
3502 #endif
3503
3504 #ifndef _WIN32
3505     if (daemonize) {
3506         pid_t pid;
3507
3508         if (pipe(fds) == -1)
3509             exit(1);
3510
3511         pid = fork();
3512         if (pid > 0) {
3513             uint8_t status;
3514             ssize_t len;
3515
3516             close(fds[1]);
3517
3518         again:
3519             len = read(fds[0], &status, 1);
3520             if (len == -1 && (errno == EINTR))
3521                 goto again;
3522
3523             if (len != 1)
3524                 exit(1);
3525             else if (status == 1) {
3526                 fprintf(stderr, "Could not acquire pidfile: %s\n", strerror(errno));
3527                 exit(1);
3528             } else
3529                 exit(0);
3530         } else if (pid < 0)
3531             exit(1);
3532
3533         close(fds[0]);
3534         qemu_set_cloexec(fds[1]);
3535
3536         setsid();
3537
3538         pid = fork();
3539         if (pid > 0)
3540             exit(0);
3541         else if (pid < 0)
3542             exit(1);
3543
3544         umask(027);
3545
3546         signal(SIGTSTP, SIG_IGN);
3547         signal(SIGTTOU, SIG_IGN);
3548         signal(SIGTTIN, SIG_IGN);
3549     }
3550 #endif
3551
3552     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
3553 #ifndef _WIN32
3554         if (daemonize) {
3555             uint8_t status = 1;
3556             if (write(fds[1], &status, 1) != 1) {
3557                 perror("daemonize. Writing to pipe\n");
3558             }
3559         } else
3560 #endif
3561             fprintf(stderr, "Could not acquire pid file: %s\n", strerror(errno));
3562         exit(1);
3563     }
3564
3565     if (kvm_allowed) {
3566         int ret = kvm_init(smp_cpus);
3567         if (ret < 0) {
3568             if (!kvm_available()) {
3569                 printf("KVM not supported for this target\n");
3570             } else {
3571                 fprintf(stderr, "failed to initialize KVM: %s\n", strerror(-ret));
3572             }
3573             exit(1);
3574         }
3575     }
3576
3577     if (qemu_init_main_loop()) {
3578         fprintf(stderr, "qemu_init_main_loop failed\n");
3579         exit(1);
3580     }
3581     linux_boot = (kernel_filename != NULL);
3582
3583     if (!linux_boot && *kernel_cmdline != '\0') {
3584         fprintf(stderr, "-append only allowed with -kernel option\n");
3585         exit(1);
3586     }
3587
3588     if (!linux_boot && initrd_filename != NULL) {
3589         fprintf(stderr, "-initrd only allowed with -kernel option\n");
3590         exit(1);
3591     }
3592
3593 #ifndef _WIN32
3594     /* Win32 doesn't support line-buffering and requires size >= 2 */
3595     setvbuf(stdout, NULL, _IOLBF, 0);
3596 #endif
3597
3598     if (init_timer_alarm() < 0) {
3599         fprintf(stderr, "could not initialize alarm timer\n");
3600         exit(1);
3601     }
3602     configure_icount(icount_option);
3603
3604     if (net_init_clients() < 0) {
3605         exit(1);
3606     }
3607
3608     /* init the bluetooth world */
3609     if (foreach_device_config(DEV_BT, bt_parse))
3610         exit(1);
3611
3612     /* init the memory */
3613     if (ram_size == 0)
3614         ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
3615
3616     /* init the dynamic translator */
3617     cpu_exec_init_all(tb_size * 1024 * 1024);
3618
3619     bdrv_init_with_whitelist();
3620
3621     blk_mig_init();
3622
3623     if (default_cdrom) {
3624         /* we always create the cdrom drive, even if no disk is there */
3625         drive_add(NULL, CDROM_ALIAS);
3626     }
3627
3628     if (default_floppy) {
3629         /* we always create at least one floppy */
3630         drive_add(NULL, FD_ALIAS, 0);
3631     }
3632
3633     if (default_sdcard) {
3634         /* we always create one sd slot, even if no card is in it */
3635         drive_add(NULL, SD_ALIAS);
3636     }
3637
3638     /* open the virtual block devices */
3639     if (snapshot)
3640         qemu_opts_foreach(&qemu_drive_opts, drive_enable_snapshot, NULL, 0);
3641     if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, machine, 1) != 0)
3642         exit(1);
3643
3644     register_savevm_live("ram", 0, 3, NULL, ram_save_live, NULL,
3645                          ram_load, NULL);
3646
3647     if (nb_numa_nodes > 0) {
3648         int i;
3649
3650         if (nb_numa_nodes > smp_cpus) {
3651             nb_numa_nodes = smp_cpus;
3652         }
3653
3654         /* If no memory size if given for any node, assume the default case
3655          * and distribute the available memory equally across all nodes
3656          */
3657         for (i = 0; i < nb_numa_nodes; i++) {
3658             if (node_mem[i] != 0)
3659                 break;
3660         }
3661         if (i == nb_numa_nodes) {
3662             uint64_t usedmem = 0;
3663
3664             /* On Linux, the each node's border has to be 8MB aligned,
3665              * the final node gets the rest.
3666              */
3667             for (i = 0; i < nb_numa_nodes - 1; i++) {
3668                 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
3669                 usedmem += node_mem[i];
3670             }
3671             node_mem[i] = ram_size - usedmem;
3672         }
3673
3674         for (i = 0; i < nb_numa_nodes; i++) {
3675             if (node_cpumask[i] != 0)
3676                 break;
3677         }
3678         /* assigning the VCPUs round-robin is easier to implement, guest OSes
3679          * must cope with this anyway, because there are BIOSes out there in
3680          * real machines which also use this scheme.
3681          */
3682         if (i == nb_numa_nodes) {
3683             for (i = 0; i < smp_cpus; i++) {
3684                 node_cpumask[i % nb_numa_nodes] |= 1 << i;
3685             }
3686         }
3687     }
3688
3689     if (qemu_opts_foreach(&qemu_mon_opts, mon_init_func, NULL, 1) != 0) {
3690         exit(1);
3691     }
3692
3693     if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
3694         exit(1);
3695     if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
3696         exit(1);
3697     if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
3698         exit(1);
3699     if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
3700         exit(1);
3701
3702     module_call_init(MODULE_INIT_DEVICE);
3703
3704     if (qemu_opts_foreach(&qemu_device_opts, device_help_func, NULL, 0) != 0)
3705         exit(0);
3706
3707     if (watchdog) {
3708         i = select_watchdog(watchdog);
3709         if (i > 0)
3710             exit (i == 1 ? 1 : 0);
3711     }
3712
3713     if (machine->compat_props) {
3714         qdev_prop_register_global_list(machine->compat_props);
3715     }
3716     qemu_add_globals();
3717
3718     machine->init(ram_size, boot_devices,
3719                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
3720
3721     cpu_synchronize_all_post_init();
3722
3723 #ifndef _WIN32
3724     /* must be after terminal init, SDL library changes signal handlers */
3725     sighandler_setup();
3726 #endif
3727
3728     set_numa_modes();
3729
3730     current_machine = machine;
3731
3732     /* init USB devices */
3733     if (usb_enabled) {
3734         if (foreach_device_config(DEV_USB, usb_parse) < 0)
3735             exit(1);
3736     }
3737
3738     /* init generic devices */
3739     if (qemu_opts_foreach(&qemu_device_opts, device_init_func, NULL, 1) != 0)
3740         exit(1);
3741
3742     net_check_clients();
3743
3744     /* just use the first displaystate for the moment */
3745     ds = get_displaystate();
3746
3747     if (display_type == DT_DEFAULT) {
3748 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
3749         display_type = DT_SDL;
3750 #else
3751         display_type = DT_VNC;
3752         vnc_display = "localhost:0,to=99";
3753         show_vnc_port = 1;
3754 #endif
3755     }
3756
3757
3758     switch (display_type) {
3759     case DT_NOGRAPHIC:
3760         break;
3761 #if defined(CONFIG_CURSES)
3762     case DT_CURSES:
3763         curses_display_init(ds, full_screen);
3764         break;
3765 #endif
3766 #if defined(CONFIG_SDL)
3767     case DT_SDL:
3768         sdl_display_init(ds, full_screen, no_frame);
3769         break;
3770 #elif defined(CONFIG_COCOA)
3771     case DT_SDL:
3772         cocoa_display_init(ds, full_screen);
3773         break;
3774 #endif
3775     case DT_VNC:
3776         vnc_display_init(ds);
3777         if (vnc_display_open(ds, vnc_display) < 0)
3778             exit(1);
3779
3780         if (show_vnc_port) {
3781             printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
3782         }
3783         break;
3784     default:
3785         break;
3786     }
3787     dpy_resize(ds);
3788
3789     dcl = ds->listeners;
3790     while (dcl != NULL) {
3791         if (dcl->dpy_refresh != NULL) {
3792             ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
3793             qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
3794         }
3795         dcl = dcl->next;
3796     }
3797
3798     if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
3799         nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
3800         qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
3801     }
3802
3803     text_consoles_set_display(ds);
3804
3805     if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
3806         fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
3807                 gdbstub_dev);
3808         exit(1);
3809     }
3810
3811     qdev_machine_creation_done();
3812
3813     if (rom_load_all() != 0) {
3814         fprintf(stderr, "rom loading failed\n");
3815         exit(1);
3816     }
3817
3818     qemu_system_reset();
3819     if (loadvm) {
3820         if (load_vmstate(loadvm) < 0) {
3821             autostart = 0;
3822         }
3823     }
3824
3825     if (incoming) {
3826         qemu_start_incoming_migration(incoming);
3827     } else if (autostart) {
3828         vm_start();
3829     }
3830
3831 #ifndef _WIN32
3832     if (daemonize) {
3833         uint8_t status = 0;
3834         ssize_t len;
3835
3836     again1:
3837         len = write(fds[1], &status, 1);
3838         if (len == -1 && (errno == EINTR))
3839             goto again1;
3840
3841         if (len != 1)
3842             exit(1);
3843
3844         if (chdir("/")) {
3845             perror("not able to chdir to /");
3846             exit(1);
3847         }
3848         TFR(fd = qemu_open("/dev/null", O_RDWR));
3849         if (fd == -1)
3850             exit(1);
3851     }
3852
3853     if (run_as) {
3854         pwd = getpwnam(run_as);
3855         if (!pwd) {
3856             fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
3857             exit(1);
3858         }
3859     }
3860
3861     if (chroot_dir) {
3862         if (chroot(chroot_dir) < 0) {
3863             fprintf(stderr, "chroot failed\n");
3864             exit(1);
3865         }
3866         if (chdir("/")) {
3867             perror("not able to chdir to /");
3868             exit(1);
3869         }
3870     }
3871
3872     if (run_as) {
3873         if (setgid(pwd->pw_gid) < 0) {
3874             fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
3875             exit(1);
3876         }
3877         if (setuid(pwd->pw_uid) < 0) {
3878             fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
3879             exit(1);
3880         }
3881         if (setuid(0) != -1) {
3882             fprintf(stderr, "Dropping privileges failed\n");
3883             exit(1);
3884         }
3885     }
3886
3887     if (daemonize) {
3888         dup2(fd, 0);
3889         dup2(fd, 1);
3890         dup2(fd, 2);
3891
3892         close(fd);
3893     }
3894 #endif
3895
3896     main_loop();
3897     quit_timers();
3898     net_cleanup();
3899
3900     return 0;
3901 }