softmmu/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
  25 #include "qemu/osdep.h"
  26 #include "qemu/help-texts.h"
  27 #include "qemu/datadir.h"
  28 #include "qemu/units.h"
  29 #include "exec/cpu-common.h"
  30 #include "exec/page-vary.h"
  31 #include "hw/qdev-properties.h"
  32 #include "qapi/compat-policy.h"
  33 #include "qapi/error.h"
  34 #include "qapi/qmp/qdict.h"
  35 #include "qapi/qmp/qstring.h"
  36 #include "qapi/qmp/qjson.h"
  37 #include "qemu-version.h"
  38 #include "qemu/cutils.h"
  39 #include "qemu/help_option.h"
  40 #include "qemu/hw-version.h"
  41 #include "qemu/uuid.h"
  42 #include "sysemu/reset.h"
  43 #include "sysemu/runstate.h"
  44 #include "sysemu/runstate-action.h"
  45 #include "sysemu/seccomp.h"
  46 #include "sysemu/tcg.h"
  47 #include "sysemu/xen.h"
  48
  49 #include "qemu/error-report.h"
  50 #include "qemu/sockets.h"
  51 #include "qemu/accel.h"
  52 #include "hw/usb.h"
  53 #include "hw/isa/isa.h"
  54 #include "hw/scsi/scsi.h"
  55 #include "hw/display/vga.h"
  56 #include "hw/firmware/smbios.h"
  57 #include "hw/acpi/acpi.h"
  58 #include "hw/xen/xen.h"
  59 #include "hw/loader.h"
  60 #include "monitor/qdev.h"
  61 #include "net/net.h"
  62 #include "net/slirp.h"
  63 #include "monitor/monitor.h"
  64 #include "ui/console.h"
  65 #include "ui/input.h"
  66 #include "sysemu/sysemu.h"
  67 #include "sysemu/numa.h"
  68 #include "sysemu/hostmem.h"
  69 #include "exec/gdbstub.h"
  70 #include "qemu/timer.h"
  71 #include "chardev/char.h"
  72 #include "qemu/bitmap.h"
  73 #include "qemu/log.h"
  74 #include "sysemu/blockdev.h"
  75 #include "hw/block/block.h"
  76 #include "hw/i386/x86.h"
  77 #include "hw/i386/pc.h"
  78 #include "migration/misc.h"
  79 #include "migration/snapshot.h"
  80 #include "sysemu/tpm.h"
  81 #include "sysemu/dma.h"
  82 #include "hw/audio/soundhw.h"
  83 #include "audio/audio.h"
  84 #include "sysemu/cpus.h"
  85 #include "sysemu/cpu-timers.h"
  86 #include "migration/colo.h"
  87 #include "migration/postcopy-ram.h"
  88 #include "sysemu/kvm.h"
  89 #include "sysemu/hax.h"
  90 #include "qapi/qobject-input-visitor.h"
  91 #include "qemu/option.h"
  92 #include "qemu/config-file.h"
  93 #include "qemu/qemu-options.h"
  94 #include "qemu/main-loop.h"
  95 #ifdef CONFIG_VIRTFS
  96 #include "fsdev/qemu-fsdev.h"
  97 #endif
  98 #include "sysemu/qtest.h"
  99 #ifdef CONFIG_TCG
 100 #include "accel/tcg/perf.h"
 101 #endif
 102
 103 #include "disas/disas.h"
 104
 105 #include "trace.h"
 106 #include "trace/control.h"
 107 #include "qemu/plugin.h"
 108 #include "qemu/queue.h"
 109 #include "sysemu/arch_init.h"
 110 #include "exec/confidential-guest-support.h"
 111
 112 #include "ui/qemu-spice.h"
 113 #include "qapi/string-input-visitor.h"
 114 #include "qapi/opts-visitor.h"
 115 #include "qapi/clone-visitor.h"
 116 #include "qom/object_interfaces.h"
 117 #include "semihosting/semihost.h"
 118 #include "crypto/init.h"
 119 #include "sysemu/replay.h"
 120 #include "qapi/qapi-events-run-state.h"
 121 #include "qapi/qapi-types-audio.h"
 122 #include "qapi/qapi-visit-audio.h"
 123 #include "qapi/qapi-visit-block-core.h"
 124 #include "qapi/qapi-visit-compat.h"
 125 #include "qapi/qapi-visit-machine.h"
 126 #include "qapi/qapi-visit-ui.h"
 127 #include "qapi/qapi-commands-block-core.h"
 128 #include "qapi/qapi-commands-migration.h"
 129 #include "qapi/qapi-commands-misc.h"
 130 #include "qapi/qapi-visit-qom.h"
 131 #include "qapi/qapi-commands-ui.h"
 132 #include "block/qdict.h"
 133 #include "qapi/qmp/qerror.h"
 134 #include "sysemu/iothread.h"
 135 #include "qemu/guest-random.h"
 136 #include "qemu/keyval.h"
 137
 138 #define MAX_VIRTIO_CONSOLES 1
 139
 140 typedef struct BlockdevOptionsQueueEntry {
 141     BlockdevOptions *bdo;
 142     Location loc;
 143     QSIMPLEQ_ENTRY(BlockdevOptionsQueueEntry) entry;
 144 } BlockdevOptionsQueueEntry;
 145
 146 typedef QSIMPLEQ_HEAD(, BlockdevOptionsQueueEntry) BlockdevOptionsQueue;
 147
 148 typedef struct ObjectOption {
 149     ObjectOptions *opts;
 150     QTAILQ_ENTRY(ObjectOption) next;
 151 } ObjectOption;
 152
 153 typedef struct DeviceOption {
 154     QDict *opts;
 155     Location loc;
 156     QTAILQ_ENTRY(DeviceOption) next;
 157 } DeviceOption;
 158
 159 static const char *cpu_option;
 160 static const char *mem_path;
 161 static const char *incoming;
 162 static const char *loadvm;
 163 static const char *accelerators;
 164 static bool have_custom_ram_size;
 165 static const char *ram_memdev_id;
 166 static QDict *machine_opts_dict;
 167 static QTAILQ_HEAD(, ObjectOption) object_opts = QTAILQ_HEAD_INITIALIZER(object_opts);
 168 static QTAILQ_HEAD(, DeviceOption) device_opts = QTAILQ_HEAD_INITIALIZER(device_opts);
 169 static int display_remote;
 170 static int snapshot;
 171 static bool preconfig_requested;
 172 static QemuPluginList plugin_list = QTAILQ_HEAD_INITIALIZER(plugin_list);
 173 static BlockdevOptionsQueue bdo_queue = QSIMPLEQ_HEAD_INITIALIZER(bdo_queue);
 174 static bool nographic = false;
 175 static int mem_prealloc; /* force preallocation of physical target memory */
 176 static const char *vga_model = NULL;
 177 static DisplayOptions dpy;
 178 static int num_serial_hds;
 179 static Chardev **serial_hds;
 180 static const char *log_mask;
 181 static const char *log_file;
 182 static bool list_data_dirs;
 183 static const char *qtest_chrdev;
 184 static const char *qtest_log;
 185
 186 static int has_defaults = 1;
 187 static int default_serial = 1;
 188 static int default_parallel = 1;
 189 static int default_monitor = 1;
 190 static int default_floppy = 1;
 191 static int default_cdrom = 1;
 192 static int default_sdcard = 1;
 193 static int default_vga = 1;
 194 static int default_net = 1;
 195
 196 static struct {
 197     const char *driver;
 198     int *flag;
 199 } default_list[] = {
 200     { .driver = "isa-serial",           .flag = &default_serial    },
 201     { .driver = "isa-parallel",         .flag = &default_parallel  },
 202     { .driver = "isa-fdc",              .flag = &default_floppy    },
 203     { .driver = "floppy",               .flag = &default_floppy    },
 204     { .driver = "ide-cd",               .flag = &default_cdrom     },
 205     { .driver = "ide-hd",               .flag = &default_cdrom     },
 206     { .driver = "scsi-cd",              .flag = &default_cdrom     },
 207     { .driver = "scsi-hd",              .flag = &default_cdrom     },
 208     { .driver = "VGA",                  .flag = &default_vga       },
 209     { .driver = "isa-vga",              .flag = &default_vga       },
 210     { .driver = "cirrus-vga",           .flag = &default_vga       },
 211     { .driver = "isa-cirrus-vga",       .flag = &default_vga       },
 212     { .driver = "vmware-svga",          .flag = &default_vga       },
 213     { .driver = "qxl-vga",              .flag = &default_vga       },
 214     { .driver = "virtio-vga",           .flag = &default_vga       },
 215     { .driver = "ati-vga",              .flag = &default_vga       },
 216     { .driver = "vhost-user-vga",       .flag = &default_vga       },
 217     { .driver = "virtio-vga-gl",        .flag = &default_vga       },
 218 };
 219
 220 static QemuOptsList qemu_rtc_opts = {
 221     .name = "rtc",
 222     .head = QTAILQ_HEAD_INITIALIZER(qemu_rtc_opts.head),
 223     .merge_lists = true,
 224     .desc = {
 225         {
 226             .name = "base",
 227             .type = QEMU_OPT_STRING,
 228         },{
 229             .name = "clock",
 230             .type = QEMU_OPT_STRING,
 231         },{
 232             .name = "driftfix",
 233             .type = QEMU_OPT_STRING,
 234         },
 235         { /* end of list */ }
 236     },
 237 };
 238
 239 static QemuOptsList qemu_option_rom_opts = {
 240     .name = "option-rom",
 241     .implied_opt_name = "romfile",
 242     .head = QTAILQ_HEAD_INITIALIZER(qemu_option_rom_opts.head),
 243     .desc = {
 244         {
 245             .name = "bootindex",
 246             .type = QEMU_OPT_NUMBER,
 247         }, {
 248             .name = "romfile",
 249             .type = QEMU_OPT_STRING,
 250         },
 251         { /* end of list */ }
 252     },
 253 };
 254
 255 static QemuOptsList qemu_accel_opts = {
 256     .name = "accel",
 257     .implied_opt_name = "accel",
 258     .head = QTAILQ_HEAD_INITIALIZER(qemu_accel_opts.head),
 259     .desc = {
 260         /*
 261          * no elements => accept any
 262          * sanity checking will happen later
 263          * when setting accelerator properties
 264          */
 265         { }
 266     },
 267 };
 268
 269 static QemuOptsList qemu_boot_opts = {
 270     .name = "boot-opts",
 271     .implied_opt_name = "order",
 272     .merge_lists = true,
 273     .head = QTAILQ_HEAD_INITIALIZER(qemu_boot_opts.head),
 274     .desc = {
 275         {
 276             .name = "order",
 277             .type = QEMU_OPT_STRING,
 278         }, {
 279             .name = "once",
 280             .type = QEMU_OPT_STRING,
 281         }, {
 282             .name = "menu",
 283             .type = QEMU_OPT_BOOL,
 284         }, {
 285             .name = "splash",
 286             .type = QEMU_OPT_STRING,
 287         }, {
 288             .name = "splash-time",
 289             .type = QEMU_OPT_NUMBER,
 290         }, {
 291             .name = "reboot-timeout",
 292             .type = QEMU_OPT_NUMBER,
 293         }, {
 294             .name = "strict",
 295             .type = QEMU_OPT_BOOL,
 296         },
 297         { /*End of list */ }
 298     },
 299 };
 300
 301 static QemuOptsList qemu_add_fd_opts = {
 302     .name = "add-fd",
 303     .head = QTAILQ_HEAD_INITIALIZER(qemu_add_fd_opts.head),
 304     .desc = {
 305         {
 306             .name = "fd",
 307             .type = QEMU_OPT_NUMBER,
 308             .help = "file descriptor of which a duplicate is added to fd set",
 309         },{
 310             .name = "set",
 311             .type = QEMU_OPT_NUMBER,
 312             .help = "ID of the fd set to add fd to",
 313         },{
 314             .name = "opaque",
 315             .type = QEMU_OPT_STRING,
 316             .help = "free-form string used to describe fd",
 317         },
 318         { /* end of list */ }
 319     },
 320 };
 321
 322 static QemuOptsList qemu_object_opts = {
 323     .name = "object",
 324     .implied_opt_name = "qom-type",
 325     .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
 326     .desc = {
 327         { }
 328     },
 329 };
 330
 331 static QemuOptsList qemu_tpmdev_opts = {
 332     .name = "tpmdev",
 333     .implied_opt_name = "type",
 334     .head = QTAILQ_HEAD_INITIALIZER(qemu_tpmdev_opts.head),
 335     .desc = {
 336         /* options are defined in the TPM backends */
 337         { /* end of list */ }
 338     },
 339 };
 340
 341 static QemuOptsList qemu_overcommit_opts = {
 342     .name = "overcommit",
 343     .head = QTAILQ_HEAD_INITIALIZER(qemu_overcommit_opts.head),
 344     .desc = {
 345         {
 346             .name = "mem-lock",
 347             .type = QEMU_OPT_BOOL,
 348         },
 349         {
 350             .name = "cpu-pm",
 351             .type = QEMU_OPT_BOOL,
 352         },
 353         { /* end of list */ }
 354     },
 355 };
 356
 357 static QemuOptsList qemu_msg_opts = {
 358     .name = "msg",
 359     .head = QTAILQ_HEAD_INITIALIZER(qemu_msg_opts.head),
 360     .desc = {
 361         {
 362             .name = "timestamp",
 363             .type = QEMU_OPT_BOOL,
 364         },
 365         {
 366             .name = "guest-name",
 367             .type = QEMU_OPT_BOOL,
 368             .help = "Prepends guest name for error messages but only if "
 369                     "-name guest is set otherwise option is ignored\n",
 370         },
 371         { /* end of list */ }
 372     },
 373 };
 374
 375 static QemuOptsList qemu_name_opts = {
 376     .name = "name",
 377     .implied_opt_name = "guest",
 378     .merge_lists = true,
 379     .head = QTAILQ_HEAD_INITIALIZER(qemu_name_opts.head),
 380     .desc = {
 381         {
 382             .name = "guest",
 383             .type = QEMU_OPT_STRING,
 384             .help = "Sets the name of the guest.\n"
 385                     "This name will be displayed in the SDL window caption.\n"
 386                     "The name will also be used for the VNC server",
 387         }, {
 388             .name = "process",
 389             .type = QEMU_OPT_STRING,
 390             .help = "Sets the name of the QEMU process, as shown in top etc",
 391         }, {
 392             .name = "debug-threads",
 393             .type = QEMU_OPT_BOOL,
 394             .help = "When enabled, name the individual threads; defaults off.\n"
 395                     "NOTE: The thread names are for debugging and not a\n"
 396                     "stable API.",
 397         },
 398         { /* End of list */ }
 399     },
 400 };
 401
 402 static QemuOptsList qemu_mem_opts = {
 403     .name = "memory",
 404     .implied_opt_name = "size",
 405     .head = QTAILQ_HEAD_INITIALIZER(qemu_mem_opts.head),
 406     .merge_lists = true,
 407     .desc = {
 408         {
 409             .name = "size",
 410             .type = QEMU_OPT_SIZE,
 411         },
 412         {
 413             .name = "slots",
 414             .type = QEMU_OPT_NUMBER,
 415         },
 416         {
 417             .name = "maxmem",
 418             .type = QEMU_OPT_SIZE,
 419         },
 420         { /* end of list */ }
 421     },
 422 };
 423
 424 static QemuOptsList qemu_icount_opts = {
 425     .name = "icount",
 426     .implied_opt_name = "shift",
 427     .merge_lists = true,
 428     .head = QTAILQ_HEAD_INITIALIZER(qemu_icount_opts.head),
 429     .desc = {
 430         {
 431             .name = "shift",
 432             .type = QEMU_OPT_STRING,
 433         }, {
 434             .name = "align",
 435             .type = QEMU_OPT_BOOL,
 436         }, {
 437             .name = "sleep",
 438             .type = QEMU_OPT_BOOL,
 439         }, {
 440             .name = "rr",
 441             .type = QEMU_OPT_STRING,
 442         }, {
 443             .name = "rrfile",
 444             .type = QEMU_OPT_STRING,
 445         }, {
 446             .name = "rrsnapshot",
 447             .type = QEMU_OPT_STRING,
 448         },
 449         { /* end of list */ }
 450     },
 451 };
 452
 453 static QemuOptsList qemu_fw_cfg_opts = {
 454     .name = "fw_cfg",
 455     .implied_opt_name = "name",
 456     .head = QTAILQ_HEAD_INITIALIZER(qemu_fw_cfg_opts.head),
 457     .desc = {
 458         {
 459             .name = "name",
 460             .type = QEMU_OPT_STRING,
 461             .help = "Sets the fw_cfg name of the blob to be inserted",
 462         }, {
 463             .name = "file",
 464             .type = QEMU_OPT_STRING,
 465             .help = "Sets the name of the file from which "
 466                     "the fw_cfg blob will be loaded",
 467         }, {
 468             .name = "string",
 469             .type = QEMU_OPT_STRING,
 470             .help = "Sets content of the blob to be inserted from a string",
 471         }, {
 472             .name = "gen_id",
 473             .type = QEMU_OPT_STRING,
 474             .help = "Sets id of the object generating the fw_cfg blob "
 475                     "to be inserted",
 476         },
 477         { /* end of list */ }
 478     },
 479 };
 480
 481 static QemuOptsList qemu_action_opts = {
 482     .name = "action",
 483     .merge_lists = true,
 484     .head = QTAILQ_HEAD_INITIALIZER(qemu_action_opts.head),
 485     .desc = {
 486         {
 487             .name = "shutdown",
 488             .type = QEMU_OPT_STRING,
 489         },{
 490             .name = "reboot",
 491             .type = QEMU_OPT_STRING,
 492         },{
 493             .name = "panic",
 494             .type = QEMU_OPT_STRING,
 495         },{
 496             .name = "watchdog",
 497             .type = QEMU_OPT_STRING,
 498         },
 499         { /* end of list */ }
 500     },
 501 };
 502
 503 const char *qemu_get_vm_name(void)
 504 {
 505     return qemu_name;
 506 }
 507
 508 static void default_driver_disable(const char *driver)
 509 {
 510     int i;
 511
 512     if (!driver) {
 513         return;
 514     }
 515
 516     for (i = 0; i < ARRAY_SIZE(default_list); i++) {
 517         if (strcmp(default_list[i].driver, driver) != 0)
 518             continue;
 519         *(default_list[i].flag) = 0;
 520     }
 521 }
 522
 523 static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp)
 524 {
 525     const char *driver = qemu_opt_get(opts, "driver");
 526
 527     default_driver_disable(driver);
 528     return 0;
 529 }
 530
 531 static void default_driver_check_json(void)
 532 {
 533     DeviceOption *opt;
 534
 535     QTAILQ_FOREACH(opt, &device_opts, next) {
 536         const char *driver = qdict_get_try_str(opt->opts, "driver");
 537         default_driver_disable(driver);
 538     }
 539 }
 540
 541 static int parse_name(void *opaque, QemuOpts *opts, Error **errp)
 542 {
 543     const char *proc_name;
 544
 545     if (qemu_opt_get(opts, "debug-threads")) {
 546         qemu_thread_naming(qemu_opt_get_bool(opts, "debug-threads", false));
 547     }
 548     qemu_name = qemu_opt_get(opts, "guest");
 549
 550     proc_name = qemu_opt_get(opts, "process");
 551     if (proc_name) {
 552         os_set_proc_name(proc_name);
 553     }
 554
 555     return 0;
 556 }
 557
 558 bool defaults_enabled(void)
 559 {
 560     return has_defaults;
 561 }
 562
 563 #ifndef _WIN32
 564 static int parse_add_fd(void *opaque, QemuOpts *opts, Error **errp)
 565 {
 566     int fd, dupfd, flags;
 567     int64_t fdset_id;
 568     const char *fd_opaque = NULL;
 569     AddfdInfo *fdinfo;
 570
 571     fd = qemu_opt_get_number(opts, "fd", -1);
 572     fdset_id = qemu_opt_get_number(opts, "set", -1);
 573     fd_opaque = qemu_opt_get(opts, "opaque");
 574
 575     if (fd < 0) {
 576         error_setg(errp, "fd option is required and must be non-negative");
 577         return -1;
 578     }
 579
 580     if (fd <= STDERR_FILENO) {
 581         error_setg(errp, "fd cannot be a standard I/O stream");
 582         return -1;
 583     }
 584
 585     /*
 586      * All fds inherited across exec() necessarily have FD_CLOEXEC
 587      * clear, while qemu sets FD_CLOEXEC on all other fds used internally.
 588      */
 589     flags = fcntl(fd, F_GETFD);
 590     if (flags == -1 || (flags & FD_CLOEXEC)) {
 591         error_setg(errp, "fd is not valid or already in use");
 592         return -1;
 593     }
 594
 595     if (fdset_id < 0) {
 596         error_setg(errp, "set option is required and must be non-negative");
 597         return -1;
 598     }
 599
 600 #ifdef F_DUPFD_CLOEXEC
 601     dupfd = fcntl(fd, F_DUPFD_CLOEXEC, 0);
 602 #else
 603     dupfd = dup(fd);
 604     if (dupfd != -1) {
 605         qemu_set_cloexec(dupfd);
 606     }
 607 #endif
 608     if (dupfd == -1) {
 609         error_setg(errp, "error duplicating fd: %s", strerror(errno));
 610         return -1;
 611     }
 612
 613     /* add the duplicate fd, and optionally the opaque string, to the fd set */
 614     fdinfo = monitor_fdset_add_fd(dupfd, true, fdset_id, fd_opaque,
 615                                   &error_abort);
 616     g_free(fdinfo);
 617
 618     return 0;
 619 }
 620
 621 static int cleanup_add_fd(void *opaque, QemuOpts *opts, Error **errp)
 622 {
 623     int fd;
 624
 625     fd = qemu_opt_get_number(opts, "fd", -1);
 626     close(fd);
 627
 628     return 0;
 629 }
 630 #endif
 631
 632 /***********************************************************/
 633 /* QEMU Block devices */
 634
 635 #define HD_OPTS "media=disk"
 636 #define CDROM_OPTS "media=cdrom"
 637 #define FD_OPTS ""
 638 #define PFLASH_OPTS ""
 639 #define MTD_OPTS ""
 640 #define SD_OPTS ""
 641
 642 static int drive_init_func(void *opaque, QemuOpts *opts, Error **errp)
 643 {
 644     BlockInterfaceType *block_default_type = opaque;
 645
 646     return drive_new(opts, *block_default_type, errp) == NULL;
 647 }
 648
 649 static int drive_enable_snapshot(void *opaque, QemuOpts *opts, Error **errp)
 650 {
 651     if (qemu_opt_get(opts, "snapshot") == NULL) {
 652         qemu_opt_set(opts, "snapshot", "on", &error_abort);
 653     }
 654     return 0;
 655 }
 656
 657 static void default_drive(int enable, int snapshot, BlockInterfaceType type,
 658                           int index, const char *optstr)
 659 {
 660     QemuOpts *opts;
 661     DriveInfo *dinfo;
 662
 663     if (!enable || drive_get_by_index(type, index)) {
 664         return;
 665     }
 666
 667     opts = drive_add(type, index, NULL, optstr);
 668     if (snapshot) {
 669         drive_enable_snapshot(NULL, opts, NULL);
 670     }
 671
 672     dinfo = drive_new(opts, type, &error_abort);
 673     dinfo->is_default = true;
 674
 675 }
 676
 677 static void configure_blockdev(BlockdevOptionsQueue *bdo_queue,
 678                                MachineClass *machine_class, int snapshot)
 679 {
 680     /*
 681      * If the currently selected machine wishes to override the
 682      * units-per-bus property of its default HBA interface type, do so
 683      * now.
 684      */
 685     if (machine_class->units_per_default_bus) {
 686         override_max_devs(machine_class->block_default_type,
 687                           machine_class->units_per_default_bus);
 688     }
 689
 690     /* open the virtual block devices */
 691     while (!QSIMPLEQ_EMPTY(bdo_queue)) {
 692         BlockdevOptionsQueueEntry *bdo = QSIMPLEQ_FIRST(bdo_queue);
 693
 694         QSIMPLEQ_REMOVE_HEAD(bdo_queue, entry);
 695         loc_push_restore(&bdo->loc);
 696         qmp_blockdev_add(bdo->bdo, &error_fatal);
 697         loc_pop(&bdo->loc);
 698         qapi_free_BlockdevOptions(bdo->bdo);
 699         g_free(bdo);
 700     }
 701     if (snapshot) {
 702         qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot,
 703                           NULL, NULL);
 704     }
 705     if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func,
 706                           &machine_class->block_default_type, &error_fatal)) {
 707         /* We printed help */
 708         exit(0);
 709     }
 710
 711     default_drive(default_cdrom, snapshot, machine_class->block_default_type, 2,
 712                   CDROM_OPTS);
 713     default_drive(default_floppy, snapshot, IF_FLOPPY, 0, FD_OPTS);
 714     default_drive(default_sdcard, snapshot, IF_SD, 0, SD_OPTS);
 715
 716 }
 717
 718 static QemuOptsList qemu_smp_opts = {
 719     .name = "smp-opts",
 720     .implied_opt_name = "cpus",
 721     .merge_lists = true,
 722     .head = QTAILQ_HEAD_INITIALIZER(qemu_smp_opts.head),
 723     .desc = {
 724         {
 725             .name = "cpus",
 726             .type = QEMU_OPT_NUMBER,
 727         }, {
 728             .name = "sockets",
 729             .type = QEMU_OPT_NUMBER,
 730         }, {
 731             .name = "dies",
 732             .type = QEMU_OPT_NUMBER,
 733         }, {
 734             .name = "clusters",
 735             .type = QEMU_OPT_NUMBER,
 736         }, {
 737             .name = "cores",
 738             .type = QEMU_OPT_NUMBER,
 739         }, {
 740             .name = "threads",
 741             .type = QEMU_OPT_NUMBER,
 742         }, {
 743             .name = "maxcpus",
 744             .type = QEMU_OPT_NUMBER,
 745         },
 746         { /*End of list */ }
 747     },
 748 };
 749
 750 static void realtime_init(void)
 751 {
 752     if (enable_mlock) {
 753         if (os_mlock() < 0) {
 754             error_report("locking memory failed");
 755             exit(1);
 756         }
 757     }
 758 }
 759
 760
 761 static void configure_msg(QemuOpts *opts)
 762 {
 763     message_with_timestamp = qemu_opt_get_bool(opts, "timestamp", false);
 764     error_with_guestname = qemu_opt_get_bool(opts, "guest-name", false);
 765 }
 766
 767
 768 /***********************************************************/
 769 /* USB devices */
 770
 771 static int usb_device_add(const char *devname)
 772 {
 773     USBDevice *dev = NULL;
 774
 775     if (!machine_usb(current_machine)) {
 776         return -1;
 777     }
 778
 779     dev = usbdevice_create(devname);
 780     if (!dev)
 781         return -1;
 782
 783     return 0;
 784 }
 785
 786 static int usb_parse(const char *cmdline)
 787 {
 788     int r;
 789     r = usb_device_add(cmdline);
 790     if (r < 0) {
 791         error_report("could not add USB device '%s'", cmdline);
 792     }
 793     return r;
 794 }
 795
 796 /***********************************************************/
 797 /* machine registration */
 798
 799 static MachineClass *find_machine(const char *name, GSList *machines)
 800 {
 801     GSList *el;
 802
 803     for (el = machines; el; el = el->next) {
 804         MachineClass *mc = el->data;
 805
 806         if (!strcmp(mc->name, name) || !g_strcmp0(mc->alias, name)) {
 807             return mc;
 808         }
 809     }
 810
 811     return NULL;
 812 }
 813
 814 static MachineClass *find_default_machine(GSList *machines)
 815 {
 816     GSList *el;
 817     MachineClass *default_machineclass = NULL;
 818
 819     for (el = machines; el; el = el->next) {
 820         MachineClass *mc = el->data;
 821
 822         if (mc->is_default) {
 823             assert(default_machineclass == NULL && "Multiple default machines");
 824             default_machineclass = mc;
 825         }
 826     }
 827
 828     return default_machineclass;
 829 }
 830
 831 static void version(void)
 832 {
 833     printf("QEMU emulator version " QEMU_FULL_VERSION "\n"
 834            QEMU_COPYRIGHT "\n");
 835 }
 836
 837 static void help(int exitcode)
 838 {
 839     version();
 840     printf("usage: %s [options] [disk_image]\n\n"
 841            "'disk_image' is a raw hard disk image for IDE hard disk 0\n\n",
 842             g_get_prgname());
 843
 844 #define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)    \
 845     if ((arch_mask) & arch_type)                               \
 846         fputs(opt_help, stdout);
 847
 848 #define ARCHHEADING(text, arch_mask) \
 849     if ((arch_mask) & arch_type)    \
 850         puts(stringify(text));
 851
 852 #define DEFHEADING(text) ARCHHEADING(text, QEMU_ARCH_ALL)
 853
 854 #include "qemu-options.def"
 855
 856     printf("\nDuring emulation, the following keys are useful:\n"
 857            "ctrl-alt-f      toggle full screen\n"
 858            "ctrl-alt-n      switch to virtual console 'n'\n"
 859            "ctrl-alt        toggle mouse and keyboard grab\n"
 860            "\n"
 861            "When using -nographic, press 'ctrl-a h' to get some help.\n"
 862            "\n"
 863            QEMU_HELP_BOTTOM "\n");
 864
 865     exit(exitcode);
 866 }
 867
 868 #define HAS_ARG 0x0001
 869
 870 typedef struct QEMUOption {
 871     const char *name;
 872     int flags;
 873     int index;
 874     uint32_t arch_mask;
 875 } QEMUOption;
 876
 877 static const QEMUOption qemu_options[] = {
 878     { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
 879
 880 #define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \
 881     { option, opt_arg, opt_enum, arch_mask },
 882 #define DEFHEADING(text)
 883 #define ARCHHEADING(text, arch_mask)
 884
 885 #include "qemu-options.def"
 886     { /* end of list */ }
 887 };
 888
 889 typedef struct VGAInterfaceInfo {
 890     const char *opt_name;    /* option name */
 891     const char *name;        /* human-readable name */
 892     /* Class names indicating that support is available.
 893      * If no class is specified, the interface is always available */
 894     const char *class_names[2];
 895 } VGAInterfaceInfo;
 896
 897 static const VGAInterfaceInfo vga_interfaces[VGA_TYPE_MAX] = {
 898     [VGA_NONE] = {
 899         .opt_name = "none",
 900         .name = "no graphic card",
 901     },
 902     [VGA_STD] = {
 903         .opt_name = "std",
 904         .name = "standard VGA",
 905         .class_names = { "VGA", "isa-vga" },
 906     },
 907     [VGA_CIRRUS] = {
 908         .opt_name = "cirrus",
 909         .name = "Cirrus VGA",
 910         .class_names = { "cirrus-vga", "isa-cirrus-vga" },
 911     },
 912     [VGA_VMWARE] = {
 913         .opt_name = "vmware",
 914         .name = "VMWare SVGA",
 915         .class_names = { "vmware-svga" },
 916     },
 917     [VGA_VIRTIO] = {
 918         .opt_name = "virtio",
 919         .name = "Virtio VGA",
 920         .class_names = { "virtio-vga" },
 921     },
 922     [VGA_QXL] = {
 923         .opt_name = "qxl",
 924         .name = "QXL VGA",
 925         .class_names = { "qxl-vga" },
 926     },
 927     [VGA_TCX] = {
 928         .opt_name = "tcx",
 929         .name = "TCX framebuffer",
 930         .class_names = { "sun-tcx" },
 931     },
 932     [VGA_CG3] = {
 933         .opt_name = "cg3",
 934         .name = "CG3 framebuffer",
 935         .class_names = { "cgthree" },
 936     },
 937 #ifdef CONFIG_XEN_BACKEND
 938     [VGA_XENFB] = {
 939         .opt_name = "xenfb",
 940         .name = "Xen paravirtualized framebuffer",
 941     },
 942 #endif
 943 };
 944
 945 static bool vga_interface_available(VGAInterfaceType t)
 946 {
 947     const VGAInterfaceInfo *ti = &vga_interfaces[t];
 948
 949     assert(t < VGA_TYPE_MAX);
 950     return !ti->class_names[0] ||
 951            module_object_class_by_name(ti->class_names[0]) ||
 952            module_object_class_by_name(ti->class_names[1]);
 953 }
 954
 955 static const char *
 956 get_default_vga_model(const MachineClass *machine_class)
 957 {
 958     if (machine_class->default_display) {
 959         return machine_class->default_display;
 960     } else if (vga_interface_available(VGA_CIRRUS)) {
 961         return "cirrus";
 962     } else if (vga_interface_available(VGA_STD)) {
 963         return "std";
 964     }
 965
 966     return NULL;
 967 }
 968
 969 static void select_vgahw(const MachineClass *machine_class, const char *p)
 970 {
 971     const char *opts;
 972     int t;
 973
 974     if (g_str_equal(p, "help")) {
 975         const char *def = get_default_vga_model(machine_class);
 976
 977         for (t = 0; t < VGA_TYPE_MAX; t++) {
 978             const VGAInterfaceInfo *ti = &vga_interfaces[t];
 979
 980             if (vga_interface_available(t) && ti->opt_name) {
 981                 printf("%-20s %s%s\n", ti->opt_name, ti->name ?: "",
 982                         (def && g_str_equal(ti->opt_name, def)) ?
 983                         " (default)" : "");
 984             }
 985         }
 986         exit(0);
 987     }
 988
 989     assert(vga_interface_type == VGA_NONE);
 990     for (t = 0; t < VGA_TYPE_MAX; t++) {
 991         const VGAInterfaceInfo *ti = &vga_interfaces[t];
 992         if (ti->opt_name && strstart(p, ti->opt_name, &opts)) {
 993             if (!vga_interface_available(t)) {
 994                 error_report("%s not available", ti->name);
 995                 exit(1);
 996             }
 997             vga_interface_type = t;
 998             break;
 999         }
1000     }
1001     if (t == VGA_TYPE_MAX) {
1002     invalid_vga:
1003         error_report("unknown vga type: %s", p);
1004         exit(1);
1005     }
1006     while (*opts) {
1007         const char *nextopt;
1008
1009         if (strstart(opts, ",retrace=", &nextopt)) {
1010             opts = nextopt;
1011             if (strstart(opts, "dumb", &nextopt))
1012                 vga_retrace_method = VGA_RETRACE_DUMB;
1013             else if (strstart(opts, "precise", &nextopt))
1014                 vga_retrace_method = VGA_RETRACE_PRECISE;
1015             else goto invalid_vga;
1016         } else goto invalid_vga;
1017         opts = nextopt;
1018     }
1019 }
1020
1021 static void parse_display_qapi(const char *optarg)
1022 {
1023     DisplayOptions *opts;
1024     Visitor *v;
1025
1026     v = qobject_input_visitor_new_str(optarg, "type", &error_fatal);
1027
1028     visit_type_DisplayOptions(v, NULL, &opts, &error_fatal);
1029     QAPI_CLONE_MEMBERS(DisplayOptions, &dpy, opts);
1030
1031     qapi_free_DisplayOptions(opts);
1032     visit_free(v);
1033 }
1034
1035 DisplayOptions *qmp_query_display_options(Error **errp)
1036 {
1037     return QAPI_CLONE(DisplayOptions, &dpy);
1038 }
1039
1040 static void parse_display(const char *p)
1041 {
1042     const char *opts;
1043
1044     if (is_help_option(p)) {
1045         qemu_display_help();
1046         exit(0);
1047     }
1048
1049     if (strstart(p, "vnc", &opts)) {
1050         /*
1051          * vnc isn't a (local) DisplayType but a protocol for remote
1052          * display access.
1053          */
1054         if (*opts == '=') {
1055             vnc_parse(opts + 1);
1056         } else {
1057             error_report("VNC requires a display argument vnc=<display>");
1058             exit(1);
1059         }
1060     } else {
1061         parse_display_qapi(p);
1062     }
1063 }
1064
1065 static inline bool nonempty_str(const char *str)
1066 {
1067     return str && *str;
1068 }
1069
1070 static int parse_fw_cfg(void *opaque, QemuOpts *opts, Error **errp)
1071 {
1072     gchar *buf;
1073     size_t size;
1074     const char *name, *file, *str, *gen_id;
1075     FWCfgState *fw_cfg = (FWCfgState *) opaque;
1076
1077     if (fw_cfg == NULL) {
1078         error_setg(errp, "fw_cfg device not available");
1079         return -1;
1080     }
1081     name = qemu_opt_get(opts, "name");
1082     file = qemu_opt_get(opts, "file");
1083     str = qemu_opt_get(opts, "string");
1084     gen_id = qemu_opt_get(opts, "gen_id");
1085
1086     /* we need the name, and exactly one of: file, content string, gen_id */
1087     if (!nonempty_str(name) ||
1088         nonempty_str(file) + nonempty_str(str) + nonempty_str(gen_id) != 1) {
1089         error_setg(errp, "name, plus exactly one of file,"
1090                          " string and gen_id, are needed");
1091         return -1;
1092     }
1093     if (strlen(name) > FW_CFG_MAX_FILE_PATH - 1) {
1094         error_setg(errp, "name too long (max. %d char)",
1095                    FW_CFG_MAX_FILE_PATH - 1);
1096         return -1;
1097     }
1098     if (nonempty_str(gen_id)) {
1099         /*
1100          * In this particular case where the content is populated
1101          * internally, the "etc/" namespace protection is relaxed,
1102          * so do not emit a warning.
1103          */
1104     } else if (strncmp(name, "opt/", 4) != 0) {
1105         warn_report("externally provided fw_cfg item names "
1106                     "should be prefixed with \"opt/\"");
1107     }
1108     if (nonempty_str(str)) {
1109         size = strlen(str); /* NUL terminator NOT included in fw_cfg blob */
1110         buf = g_memdup(str, size);
1111     } else if (nonempty_str(gen_id)) {
1112         if (!fw_cfg_add_from_generator(fw_cfg, name, gen_id, errp)) {
1113             return -1;
1114         }
1115         return 0;
1116     } else {
1117         GError *err = NULL;
1118         if (!g_file_get_contents(file, &buf, &size, &err)) {
1119             error_setg(errp, "can't load %s: %s", file, err->message);
1120             g_error_free(err);
1121             return -1;
1122         }
1123     }
1124     /* For legacy, keep user files in a specific global order. */
1125     fw_cfg_set_order_override(fw_cfg, FW_CFG_ORDER_OVERRIDE_USER);
1126     fw_cfg_add_file(fw_cfg, name, buf, size);
1127     fw_cfg_reset_order_override(fw_cfg);
1128     return 0;
1129 }
1130
1131 static int device_help_func(void *opaque, QemuOpts *opts, Error **errp)
1132 {
1133     return qdev_device_help(opts);
1134 }
1135
1136 static int device_init_func(void *opaque, QemuOpts *opts, Error **errp)
1137 {
1138     DeviceState *dev;
1139
1140     dev = qdev_device_add(opts, errp);
1141     if (!dev && *errp) {
1142         error_report_err(*errp);
1143         return -1;
1144     } else if (dev) {
1145         object_unref(OBJECT(dev));
1146     }
1147     return 0;
1148 }
1149
1150 static int chardev_init_func(void *opaque, QemuOpts *opts, Error **errp)
1151 {
1152     Error *local_err = NULL;
1153
1154     if (!qemu_chr_new_from_opts(opts, NULL, &local_err)) {
1155         if (local_err) {
1156             error_propagate(errp, local_err);
1157             return -1;
1158         }
1159         exit(0);
1160     }
1161     return 0;
1162 }
1163
1164 #ifdef CONFIG_VIRTFS
1165 static int fsdev_init_func(void *opaque, QemuOpts *opts, Error **errp)
1166 {
1167     return qemu_fsdev_add(opts, errp);
1168 }
1169 #endif
1170
1171 static int mon_init_func(void *opaque, QemuOpts *opts, Error **errp)
1172 {
1173     return monitor_init_opts(opts, errp);
1174 }
1175
1176 static void monitor_parse(const char *optarg, const char *mode, bool pretty)
1177 {
1178     static int monitor_device_index = 0;
1179     QemuOpts *opts;
1180     const char *p;
1181     char label[32];
1182
1183     if (strstart(optarg, "chardev:", &p)) {
1184         snprintf(label, sizeof(label), "%s", p);
1185     } else {
1186         snprintf(label, sizeof(label), "compat_monitor%d",
1187                  monitor_device_index);
1188         opts = qemu_chr_parse_compat(label, optarg, true);
1189         if (!opts) {
1190             error_report("parse error: %s", optarg);
1191             exit(1);
1192         }
1193     }
1194
1195     opts = qemu_opts_create(qemu_find_opts("mon"), label, 1, &error_fatal);
1196     qemu_opt_set(opts, "mode", mode, &error_abort);
1197     qemu_opt_set(opts, "chardev", label, &error_abort);
1198     if (!strcmp(mode, "control")) {
1199         qemu_opt_set_bool(opts, "pretty", pretty, &error_abort);
1200     } else {
1201         assert(pretty == false);
1202     }
1203     monitor_device_index++;
1204 }
1205
1206 struct device_config {
1207     enum {
1208         DEV_USB,       /* -usbdevice     */
1209         DEV_SERIAL,    /* -serial        */
1210         DEV_PARALLEL,  /* -parallel      */
1211         DEV_DEBUGCON,  /* -debugcon */
1212         DEV_GDB,       /* -gdb, -s */
1213         DEV_SCLP,      /* s390 sclp */
1214     } type;
1215     const char *cmdline;
1216     Location loc;
1217     QTAILQ_ENTRY(device_config) next;
1218 };
1219
1220 static QTAILQ_HEAD(, device_config) device_configs =
1221     QTAILQ_HEAD_INITIALIZER(device_configs);
1222
1223 static void add_device_config(int type, const char *cmdline)
1224 {
1225     struct device_config *conf;
1226
1227     conf = g_malloc0(sizeof(*conf));
1228     conf->type = type;
1229     conf->cmdline = cmdline;
1230     loc_save(&conf->loc);
1231     QTAILQ_INSERT_TAIL(&device_configs, conf, next);
1232 }
1233
1234 static int foreach_device_config(int type, int (*func)(const char *cmdline))
1235 {
1236     struct device_config *conf;
1237     int rc;
1238
1239     QTAILQ_FOREACH(conf, &device_configs, next) {
1240         if (conf->type != type)
1241             continue;
1242         loc_push_restore(&conf->loc);
1243         rc = func(conf->cmdline);
1244         loc_pop(&conf->loc);
1245         if (rc) {
1246             return rc;
1247         }
1248     }
1249     return 0;
1250 }
1251
1252 static void qemu_disable_default_devices(void)
1253 {
1254     MachineClass *machine_class = MACHINE_GET_CLASS(current_machine);
1255
1256     default_driver_check_json();
1257     qemu_opts_foreach(qemu_find_opts("device"),
1258                       default_driver_check, NULL, NULL);
1259     qemu_opts_foreach(qemu_find_opts("global"),
1260                       default_driver_check, NULL, NULL);
1261
1262     if (!vga_model && !default_vga) {
1263         vga_interface_type = VGA_DEVICE;
1264         vga_interface_created = true;
1265     }
1266     if (!has_defaults || machine_class->no_serial) {
1267         default_serial = 0;
1268     }
1269     if (!has_defaults || machine_class->no_parallel) {
1270         default_parallel = 0;
1271     }
1272     if (!has_defaults || machine_class->no_floppy) {
1273         default_floppy = 0;
1274     }
1275     if (!has_defaults || machine_class->no_cdrom) {
1276         default_cdrom = 0;
1277     }
1278     if (!has_defaults || machine_class->no_sdcard) {
1279         default_sdcard = 0;
1280     }
1281     if (!has_defaults) {
1282         default_monitor = 0;
1283         default_net = 0;
1284         default_vga = 0;
1285     }
1286 }
1287
1288 static void qemu_create_default_devices(void)
1289 {
1290     MachineClass *machine_class = MACHINE_GET_CLASS(current_machine);
1291
1292     if (is_daemonized()) {
1293         /* According to documentation and historically, -nographic redirects
1294          * serial port, parallel port and monitor to stdio, which does not work
1295          * with -daemonize.  We can redirect these to null instead, but since
1296          * -nographic is legacy, let's just error out.
1297          * We disallow -nographic only if all other ports are not redirected
1298          * explicitly, to not break existing legacy setups which uses
1299          * -nographic _and_ redirects all ports explicitly - this is valid
1300          * usage, -nographic is just a no-op in this case.
1301          */
1302         if (nographic
1303             && (default_parallel || default_serial || default_monitor)) {
1304             error_report("-nographic cannot be used with -daemonize");
1305             exit(1);
1306         }
1307     }
1308
1309     if (nographic) {
1310         if (default_parallel)
1311             add_device_config(DEV_PARALLEL, "null");
1312         if (default_serial && default_monitor) {
1313             add_device_config(DEV_SERIAL, "mon:stdio");
1314         } else {
1315             if (default_serial)
1316                 add_device_config(DEV_SERIAL, "stdio");
1317             if (default_monitor)
1318                 monitor_parse("stdio", "readline", false);
1319         }
1320     } else {
1321         if (default_serial)
1322             add_device_config(DEV_SERIAL, "vc:80Cx24C");
1323         if (default_parallel)
1324             add_device_config(DEV_PARALLEL, "vc:80Cx24C");
1325         if (default_monitor)
1326             monitor_parse("vc:80Cx24C", "readline", false);
1327     }
1328
1329     if (default_net) {
1330         QemuOptsList *net = qemu_find_opts("net");
1331         qemu_opts_parse(net, "nic", true, &error_abort);
1332 #ifdef CONFIG_SLIRP
1333         qemu_opts_parse(net, "user", true, &error_abort);
1334 #endif
1335     }
1336
1337 #if defined(CONFIG_VNC)
1338     if (!QTAILQ_EMPTY(&(qemu_find_opts("vnc")->head))) {
1339         display_remote++;
1340     }
1341 #endif
1342     if (dpy.type == DISPLAY_TYPE_DEFAULT && !display_remote) {
1343         if (!qemu_display_find_default(&dpy)) {
1344             dpy.type = DISPLAY_TYPE_NONE;
1345 #if defined(CONFIG_VNC)
1346             vnc_parse("localhost:0,to=99,id=default");
1347 #endif
1348         }
1349     }
1350     if (dpy.type == DISPLAY_TYPE_DEFAULT) {
1351         dpy.type = DISPLAY_TYPE_NONE;
1352     }
1353
1354     /* If no default VGA is requested, the default is "none".  */
1355     if (default_vga) {
1356         vga_model = get_default_vga_model(machine_class);
1357     }
1358     if (vga_model) {
1359         select_vgahw(machine_class, vga_model);
1360     }
1361 }
1362
1363 static int serial_parse(const char *devname)
1364 {
1365     int index = num_serial_hds;
1366     char label[32];
1367
1368     if (strcmp(devname, "none") == 0)
1369         return 0;
1370     snprintf(label, sizeof(label), "serial%d", index);
1371     serial_hds = g_renew(Chardev *, serial_hds, index + 1);
1372
1373     serial_hds[index] = qemu_chr_new_mux_mon(label, devname, NULL);
1374     if (!serial_hds[index]) {
1375         error_report("could not connect serial device"
1376                      " to character backend '%s'", devname);
1377         return -1;
1378     }
1379     num_serial_hds++;
1380     return 0;
1381 }
1382
1383 Chardev *serial_hd(int i)
1384 {
1385     assert(i >= 0);
1386     if (i < num_serial_hds) {
1387         return serial_hds[i];
1388     }
1389     return NULL;
1390 }
1391
1392 static int parallel_parse(const char *devname)
1393 {
1394     static int index = 0;
1395     char label[32];
1396
1397     if (strcmp(devname, "none") == 0)
1398         return 0;
1399     if (index == MAX_PARALLEL_PORTS) {
1400         error_report("too many parallel ports");
1401         exit(1);
1402     }
1403     snprintf(label, sizeof(label), "parallel%d", index);
1404     parallel_hds[index] = qemu_chr_new_mux_mon(label, devname, NULL);
1405     if (!parallel_hds[index]) {
1406         error_report("could not connect parallel device"
1407                      " to character backend '%s'", devname);
1408         return -1;
1409     }
1410     index++;
1411     return 0;
1412 }
1413
1414 static int debugcon_parse(const char *devname)
1415 {
1416     QemuOpts *opts;
1417
1418     if (!qemu_chr_new_mux_mon("debugcon", devname, NULL)) {
1419         error_report("invalid character backend '%s'", devname);
1420         exit(1);
1421     }
1422     opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL);
1423     if (!opts) {
1424         error_report("already have a debugcon device");
1425         exit(1);
1426     }
1427     qemu_opt_set(opts, "driver", "isa-debugcon", &error_abort);
1428     qemu_opt_set(opts, "chardev", "debugcon", &error_abort);
1429     return 0;
1430 }
1431
1432 static gint machine_class_cmp(gconstpointer a, gconstpointer b)
1433 {
1434     const MachineClass *mc1 = a, *mc2 = b;
1435     int res;
1436
1437     if (mc1->family == NULL) {
1438         if (mc2->family == NULL) {
1439             /* Compare standalone machine types against each other; they sort
1440              * in increasing order.
1441              */
1442             return strcmp(object_class_get_name(OBJECT_CLASS(mc1)),
1443                           object_class_get_name(OBJECT_CLASS(mc2)));
1444         }
1445
1446         /* Standalone machine types sort after families. */
1447         return 1;
1448     }
1449
1450     if (mc2->family == NULL) {
1451         /* Families sort before standalone machine types. */
1452         return -1;
1453     }
1454
1455     /* Families sort between each other alphabetically increasingly. */
1456     res = strcmp(mc1->family, mc2->family);
1457     if (res != 0) {
1458         return res;
1459     }
1460
1461     /* Within the same family, machine types sort in decreasing order. */
1462     return strcmp(object_class_get_name(OBJECT_CLASS(mc2)),
1463                   object_class_get_name(OBJECT_CLASS(mc1)));
1464 }
1465
1466 static void machine_help_func(const QDict *qdict)
1467 {
1468     GSList *machines, *el;
1469     const char *type = qdict_get_try_str(qdict, "type");
1470
1471     machines = object_class_get_list(TYPE_MACHINE, false);
1472     if (type) {
1473         ObjectClass *machine_class = OBJECT_CLASS(find_machine(type, machines));
1474         if (machine_class) {
1475             type_print_class_properties(object_class_get_name(machine_class));
1476             return;
1477         }
1478     }
1479
1480     printf("Supported machines are:\n");
1481     machines = g_slist_sort(machines, machine_class_cmp);
1482     for (el = machines; el; el = el->next) {
1483         MachineClass *mc = el->data;
1484         if (mc->alias) {
1485             printf("%-20s %s (alias of %s)\n", mc->alias, mc->desc, mc->name);
1486         }
1487         printf("%-20s %s%s%s\n", mc->name, mc->desc,
1488                mc->is_default ? " (default)" : "",
1489                mc->deprecation_reason ? " (deprecated)" : "");
1490     }
1491 }
1492
1493 static void
1494 machine_merge_property(const char *propname, QDict *prop, Error **errp)
1495 {
1496     QDict *opts;
1497
1498     opts = qdict_new();
1499     /* Preserve the caller's reference to prop.  */
1500     qobject_ref(prop);
1501     qdict_put(opts, propname, prop);
1502     keyval_merge(machine_opts_dict, opts, errp);
1503     qobject_unref(opts);
1504 }
1505
1506 static void
1507 machine_parse_property_opt(QemuOptsList *opts_list, const char *propname,
1508                            const char *arg)
1509 {
1510     QDict *prop = NULL;
1511     bool help = false;
1512
1513     prop = keyval_parse(arg, opts_list->implied_opt_name, &help, &error_fatal);
1514     if (help) {
1515         qemu_opts_print_help(opts_list, true);
1516         exit(0);
1517     }
1518     machine_merge_property(propname, prop, &error_fatal);
1519     qobject_unref(prop);
1520 }
1521
1522 static const char *pid_file;
1523 struct UnlinkPidfileNotifier {
1524     Notifier notifier;
1525     char *pid_file_realpath;
1526 };
1527 static struct UnlinkPidfileNotifier qemu_unlink_pidfile_notifier;
1528
1529 static void qemu_unlink_pidfile(Notifier *n, void *data)
1530 {
1531     struct UnlinkPidfileNotifier *upn;
1532
1533     upn = DO_UPCAST(struct UnlinkPidfileNotifier, notifier, n);
1534     unlink(upn->pid_file_realpath);
1535 }
1536
1537 static const QEMUOption *lookup_opt(int argc, char **argv,
1538                                     const char **poptarg, int *poptind)
1539 {
1540     const QEMUOption *popt;
1541     int optind = *poptind;
1542     char *r = argv[optind];
1543     const char *optarg;
1544
1545     loc_set_cmdline(argv, optind, 1);
1546     optind++;
1547     /* Treat --foo the same as -foo.  */
1548     if (r[1] == '-')
1549         r++;
1550     popt = qemu_options;
1551     for(;;) {
1552         if (!popt->name) {
1553             error_report("invalid option");
1554             exit(1);
1555         }
1556         if (!strcmp(popt->name, r + 1))
1557             break;
1558         popt++;
1559     }
1560     if (popt->flags & HAS_ARG) {
1561         if (optind >= argc) {
1562             error_report("requires an argument");
1563             exit(1);
1564         }
1565         optarg = argv[optind++];
1566         loc_set_cmdline(argv, optind - 2, 2);
1567     } else {
1568         optarg = NULL;
1569     }
1570
1571     *poptarg = optarg;
1572     *poptind = optind;
1573
1574     return popt;
1575 }
1576
1577 static MachineClass *select_machine(QDict *qdict, Error **errp)
1578 {
1579     const char *optarg = qdict_get_try_str(qdict, "type");
1580     GSList *machines = object_class_get_list(TYPE_MACHINE, false);
1581     MachineClass *machine_class;
1582     Error *local_err = NULL;
1583
1584     if (optarg) {
1585         machine_class = find_machine(optarg, machines);
1586         qdict_del(qdict, "type");
1587         if (!machine_class) {
1588             error_setg(&local_err, "unsupported machine type");
1589         }
1590     } else {
1591         machine_class = find_default_machine(machines);
1592         if (!machine_class) {
1593             error_setg(&local_err, "No machine specified, and there is no default");
1594         }
1595     }
1596
1597     g_slist_free(machines);
1598     if (local_err) {
1599         error_append_hint(&local_err, "Use -machine help to list supported machines\n");
1600         error_propagate(errp, local_err);
1601     }
1602     return machine_class;
1603 }
1604
1605 static int object_parse_property_opt(Object *obj,
1606                                      const char *name, const char *value,
1607                                      const char *skip, Error **errp)
1608 {
1609     if (g_str_equal(name, skip)) {
1610         return 0;
1611     }
1612
1613     if (!object_property_parse(obj, name, value, errp)) {
1614         return -1;
1615     }
1616
1617     return 0;
1618 }
1619
1620 /* *Non*recursively replace underscores with dashes in QDict keys.  */
1621 static void keyval_dashify(QDict *qdict, Error **errp)
1622 {
1623     const QDictEntry *ent, *next;
1624     char *p;
1625
1626     for (ent = qdict_first(qdict); ent; ent = next) {
1627         g_autofree char *new_key = NULL;
1628
1629         next = qdict_next(qdict, ent);
1630         if (!strchr(ent->key, '_')) {
1631             continue;
1632         }
1633         new_key = g_strdup(ent->key);
1634         for (p = new_key; *p; p++) {
1635             if (*p == '_') {
1636                 *p = '-';
1637             }
1638         }
1639         if (qdict_haskey(qdict, new_key)) {
1640             error_setg(errp, "Conflict between '%s' and '%s'", ent->key, new_key);
1641             return;
1642         }
1643         qobject_ref(ent->value);
1644         qdict_put_obj(qdict, new_key, ent->value);
1645         qdict_del(qdict, ent->key);
1646     }
1647 }
1648
1649 static void qemu_apply_legacy_machine_options(QDict *qdict)
1650 {
1651     const char *value;
1652     QObject *prop;
1653
1654     keyval_dashify(qdict, &error_fatal);
1655
1656     /* Legacy options do not correspond to MachineState properties.  */
1657     value = qdict_get_try_str(qdict, "accel");
1658     if (value) {
1659         accelerators = g_strdup(value);
1660         qdict_del(qdict, "accel");
1661     }
1662
1663     value = qdict_get_try_str(qdict, "igd-passthru");
1664     if (value) {
1665         object_register_sugar_prop(ACCEL_CLASS_NAME("xen"), "igd-passthru", value,
1666                                    false);
1667         qdict_del(qdict, "igd-passthru");
1668     }
1669
1670     value = qdict_get_try_str(qdict, "kvm-shadow-mem");
1671     if (value) {
1672         object_register_sugar_prop(ACCEL_CLASS_NAME("kvm"), "kvm-shadow-mem", value,
1673                                    false);
1674         qdict_del(qdict, "kvm-shadow-mem");
1675     }
1676
1677     value = qdict_get_try_str(qdict, "kernel-irqchip");
1678     if (value) {
1679         object_register_sugar_prop(ACCEL_CLASS_NAME("kvm"), "kernel-irqchip", value,
1680                                    false);
1681         object_register_sugar_prop(ACCEL_CLASS_NAME("whpx"), "kernel-irqchip", value,
1682                                    false);
1683         qdict_del(qdict, "kernel-irqchip");
1684     }
1685
1686     value = qdict_get_try_str(qdict, "memory-backend");
1687     if (value) {
1688         if (mem_path) {
1689             error_report("'-mem-path' can't be used together with"
1690                          "'-machine memory-backend'");
1691             exit(EXIT_FAILURE);
1692         }
1693
1694         /* Resolved later.  */
1695         ram_memdev_id = g_strdup(value);
1696         qdict_del(qdict, "memory-backend");
1697     }
1698
1699     prop = qdict_get(qdict, "memory");
1700     if (prop) {
1701         have_custom_ram_size =
1702             qobject_type(prop) == QTYPE_QDICT &&
1703             qdict_haskey(qobject_to(QDict, prop), "size");
1704     }
1705 }
1706
1707 static void object_option_foreach_add(bool (*type_opt_predicate)(const char *))
1708 {
1709     ObjectOption *opt, *next;
1710
1711     QTAILQ_FOREACH_SAFE(opt, &object_opts, next, next) {
1712         const char *type = ObjectType_str(opt->opts->qom_type);
1713         if (type_opt_predicate(type)) {
1714             user_creatable_add_qapi(opt->opts, &error_fatal);
1715             qapi_free_ObjectOptions(opt->opts);
1716             QTAILQ_REMOVE(&object_opts, opt, next);
1717             g_free(opt);
1718         }
1719     }
1720 }
1721
1722 static void object_option_add_visitor(Visitor *v)
1723 {
1724     ObjectOption *opt = g_new0(ObjectOption, 1);
1725     visit_type_ObjectOptions(v, NULL, &opt->opts, &error_fatal);
1726     QTAILQ_INSERT_TAIL(&object_opts, opt, next);
1727 }
1728
1729 static void object_option_parse(const char *optarg)
1730 {
1731     QemuOpts *opts;
1732     const char *type;
1733     Visitor *v;
1734
1735     if (optarg[0] == '{') {
1736         QObject *obj = qobject_from_json(optarg, &error_fatal);
1737
1738         v = qobject_input_visitor_new(obj);
1739         qobject_unref(obj);
1740     } else {
1741         opts = qemu_opts_parse_noisily(qemu_find_opts("object"),
1742                                        optarg, true);
1743         if (!opts) {
1744             exit(1);
1745         }
1746
1747         type = qemu_opt_get(opts, "qom-type");
1748         if (!type) {
1749             error_setg(&error_fatal, QERR_MISSING_PARAMETER, "qom-type");
1750         }
1751         if (user_creatable_print_help(type, opts)) {
1752             exit(0);
1753         }
1754
1755         v = opts_visitor_new(opts);
1756     }
1757
1758     object_option_add_visitor(v);
1759     visit_free(v);
1760 }
1761
1762 /*
1763  * Very early object creation, before the sandbox options have been activated.
1764  */
1765 static bool object_create_pre_sandbox(const char *type)
1766 {
1767     /*
1768      * Objects should in general not get initialized "too early" without
1769      * a reason. If you add one, state the reason in a comment!
1770      */
1771
1772     /*
1773      * Reason: -sandbox on,resourcecontrol=deny disallows setting CPU
1774      * affinity of threads.
1775      */
1776     if (g_str_equal(type, "thread-context")) {
1777         return true;
1778     }
1779
1780     return false;
1781 }
1782
1783 /*
1784  * Initial object creation happens before all other
1785  * QEMU data types are created. The majority of objects
1786  * can be created at this point. The rng-egd object
1787  * cannot be created here, as it depends on the chardev
1788  * already existing.
1789  */
1790 static bool object_create_early(const char *type)
1791 {
1792     /*
1793      * Objects should not be made "delayed" without a reason.  If you
1794      * add one, state the reason in a comment!
1795      */
1796
1797     /* Reason: already created. */
1798     if (object_create_pre_sandbox(type)) {
1799         return false;
1800     }
1801
1802     /* Reason: property "chardev" */
1803     if (g_str_equal(type, "rng-egd") ||
1804         g_str_equal(type, "qtest")) {
1805         return false;
1806     }
1807
1808 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
1809     /* Reason: cryptodev-vhost-user property "chardev" */
1810     if (g_str_equal(type, "cryptodev-vhost-user")) {
1811         return false;
1812     }
1813 #endif
1814
1815     /* Reason: vhost-user-blk-server property "node-name" */
1816     if (g_str_equal(type, "vhost-user-blk-server")) {
1817         return false;
1818     }
1819     /*
1820      * Reason: filter-* property "netdev" etc.
1821      */
1822     if (g_str_equal(type, "filter-buffer") ||
1823         g_str_equal(type, "filter-dump") ||
1824         g_str_equal(type, "filter-mirror") ||
1825         g_str_equal(type, "filter-redirector") ||
1826         g_str_equal(type, "colo-compare") ||
1827         g_str_equal(type, "filter-rewriter") ||
1828         g_str_equal(type, "filter-replay")) {
1829         return false;
1830     }
1831
1832     /*
1833      * Allocation of large amounts of memory may delay
1834      * chardev initialization for too long, and trigger timeouts
1835      * on software that waits for a monitor socket to be created
1836      * (e.g. libvirt).
1837      */
1838     if (g_str_has_prefix(type, "memory-backend-")) {
1839         return false;
1840     }
1841
1842     return true;
1843 }
1844
1845 static void qemu_apply_machine_options(QDict *qdict)
1846 {
1847     object_set_properties_from_keyval(OBJECT(current_machine), qdict, false, &error_fatal);
1848
1849     if (semihosting_enabled(false) && !semihosting_get_argc()) {
1850         /* fall back to the -kernel/-append */
1851         semihosting_arg_fallback(current_machine->kernel_filename, current_machine->kernel_cmdline);
1852     }
1853
1854     if (current_machine->smp.cpus > 1) {
1855         replay_add_blocker("smp");
1856     }
1857 }
1858
1859 static void qemu_create_early_backends(void)
1860 {
1861     MachineClass *machine_class = MACHINE_GET_CLASS(current_machine);
1862 #if defined(CONFIG_SDL)
1863     const bool use_sdl = (dpy.type == DISPLAY_TYPE_SDL);
1864 #else
1865     const bool use_sdl = false;
1866 #endif
1867 #if defined(CONFIG_GTK)
1868     const bool use_gtk = (dpy.type == DISPLAY_TYPE_GTK);
1869 #else
1870     const bool use_gtk = false;
1871 #endif
1872
1873     if (dpy.has_window_close && !use_gtk && !use_sdl) {
1874         error_report("window-close is only valid for GTK and SDL, "
1875                      "ignoring option");
1876     }
1877
1878     qemu_display_early_init(&dpy);
1879     qemu_console_early_init();
1880
1881     if (dpy.has_gl && dpy.gl != DISPLAYGL_MODE_OFF && display_opengl == 0) {
1882 #if defined(CONFIG_OPENGL)
1883         error_report("OpenGL is not supported by the display");
1884 #else
1885         error_report("OpenGL support is disabled");
1886 #endif
1887         exit(1);
1888     }
1889
1890     object_option_foreach_add(object_create_early);
1891
1892     /* spice needs the timers to be initialized by this point */
1893     /* spice must initialize before audio as it changes the default audiodev */
1894     /* spice must initialize before chardevs (for spicevmc and spiceport) */
1895     qemu_spice.init();
1896
1897     qemu_opts_foreach(qemu_find_opts("chardev"),
1898                       chardev_init_func, NULL, &error_fatal);
1899
1900 #ifdef CONFIG_VIRTFS
1901     qemu_opts_foreach(qemu_find_opts("fsdev"),
1902                       fsdev_init_func, NULL, &error_fatal);
1903 #endif
1904
1905     /*
1906      * Note: we need to create audio and block backends before
1907      * setting machine properties, so they can be referred to.
1908      */
1909     configure_blockdev(&bdo_queue, machine_class, snapshot);
1910     if (!audio_init_audiodevs()) {
1911         exit(1);
1912     }
1913 }
1914
1915
1916 /*
1917  * The remainder of object creation happens after the
1918  * creation of chardev, fsdev, net clients and device data types.
1919  */
1920 static bool object_create_late(const char *type)
1921 {
1922     return !object_create_early(type) && !object_create_pre_sandbox(type);
1923 }
1924
1925 static void qemu_create_late_backends(void)
1926 {
1927     if (qtest_chrdev) {
1928         qtest_server_init(qtest_chrdev, qtest_log, &error_fatal);
1929     }
1930
1931     net_init_clients();
1932
1933     object_option_foreach_add(object_create_late);
1934
1935     if (tpm_init() < 0) {
1936         exit(1);
1937     }
1938
1939     qemu_opts_foreach(qemu_find_opts("mon"),
1940                       mon_init_func, NULL, &error_fatal);
1941
1942     if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
1943         exit(1);
1944     if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
1945         exit(1);
1946     if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
1947         exit(1);
1948
1949     /* now chardevs have been created we may have semihosting to connect */
1950     qemu_semihosting_chardev_init();
1951 }
1952
1953 static void qemu_resolve_machine_memdev(void)
1954 {
1955     if (ram_memdev_id) {
1956         Object *backend;
1957         ram_addr_t backend_size;
1958
1959         backend = object_resolve_path_type(ram_memdev_id,
1960                                            TYPE_MEMORY_BACKEND, NULL);
1961         if (!backend) {
1962             error_report("Memory backend '%s' not found", ram_memdev_id);
1963             exit(EXIT_FAILURE);
1964         }
1965         if (!have_custom_ram_size) {
1966             backend_size = object_property_get_uint(backend, "size",  &error_abort);
1967             current_machine->ram_size = backend_size;
1968         }
1969         object_property_set_link(OBJECT(current_machine),
1970                                  "memory-backend", backend, &error_fatal);
1971     }
1972 }
1973
1974 static void parse_memory_options(void)
1975 {
1976     QemuOpts *opts = qemu_find_opts_singleton("memory");
1977     QDict *dict, *prop;
1978     const char *mem_str;
1979     Location loc;
1980
1981     loc_push_none(&loc);
1982     qemu_opts_loc_restore(opts);
1983
1984     prop = qdict_new();
1985
1986     if (qemu_opt_get_size(opts, "size", 0) != 0) {
1987         /* Fix up legacy suffix-less format */
1988         mem_str = qemu_opt_get(opts, "size");
1989         if (g_ascii_isdigit(mem_str[strlen(mem_str) - 1])) {
1990             g_autofree char *mib_str = g_strdup_printf("%sM", mem_str);
1991             qdict_put_str(prop, "size", mib_str);
1992         } else {
1993             qdict_put_str(prop, "size", mem_str);
1994         }
1995     }
1996
1997     if (qemu_opt_get(opts, "maxmem")) {
1998         qdict_put_str(prop, "max-size", qemu_opt_get(opts, "maxmem"));
1999     }
2000     if (qemu_opt_get(opts, "slots")) {
2001         qdict_put_str(prop, "slots", qemu_opt_get(opts, "slots"));
2002     }
2003
2004     dict = qdict_new();
2005     qdict_put(dict, "memory", prop);
2006     keyval_merge(machine_opts_dict, dict, &error_fatal);
2007     qobject_unref(dict);
2008     loc_pop(&loc);
2009 }
2010
2011 static void qemu_create_machine(QDict *qdict)
2012 {
2013     MachineClass *machine_class = select_machine(qdict, &error_fatal);
2014     object_set_machine_compat_props(machine_class->compat_props);
2015
2016     current_machine = MACHINE(object_new_with_class(OBJECT_CLASS(machine_class)));
2017     object_property_add_child(object_get_root(), "machine",
2018                               OBJECT(current_machine));
2019     object_property_add_child(container_get(OBJECT(current_machine),
2020                                             "/unattached"),
2021                               "sysbus", OBJECT(sysbus_get_default()));
2022
2023     if (machine_class->minimum_page_bits) {
2024         if (!set_preferred_target_page_bits(machine_class->minimum_page_bits)) {
2025             /* This would be a board error: specifying a minimum smaller than
2026              * a target's compile-time fixed setting.
2027              */
2028             g_assert_not_reached();
2029         }
2030     }
2031
2032     cpu_exec_init_all();
2033     page_size_init();
2034
2035     if (machine_class->hw_version) {
2036         qemu_set_hw_version(machine_class->hw_version);
2037     }
2038
2039     /*
2040      * Get the default machine options from the machine if it is not already
2041      * specified either by the configuration file or by the command line.
2042      */
2043     if (machine_class->default_machine_opts) {
2044         QDict *default_opts =
2045             keyval_parse(machine_class->default_machine_opts, NULL, NULL,
2046                          &error_abort);
2047         qemu_apply_legacy_machine_options(default_opts);
2048         object_set_properties_from_keyval(OBJECT(current_machine), default_opts,
2049                                           false, &error_abort);
2050         qobject_unref(default_opts);
2051     }
2052 }
2053
2054 static int global_init_func(void *opaque, QemuOpts *opts, Error **errp)
2055 {
2056     GlobalProperty *g;
2057
2058     g = g_malloc0(sizeof(*g));
2059     g->driver   = qemu_opt_get(opts, "driver");
2060     g->property = qemu_opt_get(opts, "property");
2061     g->value    = qemu_opt_get(opts, "value");
2062     qdev_prop_register_global(g);
2063     return 0;
2064 }
2065
2066 /*
2067  * Return whether configuration group @group is stored in QemuOpts, or
2068  * recorded as one or more QDicts by qemu_record_config_group.
2069  */
2070 static bool is_qemuopts_group(const char *group)
2071 {
2072     if (g_str_equal(group, "object") ||
2073         g_str_equal(group, "machine") ||
2074         g_str_equal(group, "smp-opts") ||
2075         g_str_equal(group, "boot-opts")) {
2076         return false;
2077     }
2078     return true;
2079 }
2080
2081 static void qemu_record_config_group(const char *group, QDict *dict,
2082                                      bool from_json, Error **errp)
2083 {
2084     if (g_str_equal(group, "object")) {
2085         Visitor *v = qobject_input_visitor_new_keyval(QOBJECT(dict));
2086         object_option_add_visitor(v);
2087         visit_free(v);
2088     } else if (g_str_equal(group, "machine")) {
2089         /*
2090          * Cannot merge string-valued and type-safe dictionaries, so JSON
2091          * is not accepted yet for -M.
2092          */
2093         assert(!from_json);
2094         keyval_merge(machine_opts_dict, dict, errp);
2095     } else if (g_str_equal(group, "smp-opts")) {
2096         machine_merge_property("smp", dict, &error_fatal);
2097     } else if (g_str_equal(group, "boot-opts")) {
2098         machine_merge_property("boot", dict, &error_fatal);
2099     } else {
2100         abort();
2101     }
2102 }
2103
2104 /*
2105  * Parse non-QemuOpts config file groups, pass the rest to
2106  * qemu_config_do_parse.
2107  */
2108 static void qemu_parse_config_group(const char *group, QDict *qdict,
2109                                     void *opaque, Error **errp)
2110 {
2111     QObject *crumpled;
2112     if (is_qemuopts_group(group)) {
2113         qemu_config_do_parse(group, qdict, opaque, errp);
2114         return;
2115     }
2116
2117     crumpled = qdict_crumple(qdict, errp);
2118     if (!crumpled) {
2119         return;
2120     }
2121     switch (qobject_type(crumpled)) {
2122     case QTYPE_QDICT:
2123         qemu_record_config_group(group, qobject_to(QDict, crumpled), false, errp);
2124         break;
2125     case QTYPE_QLIST:
2126         error_setg(errp, "Lists cannot be at top level of a configuration section");
2127         break;
2128     default:
2129         g_assert_not_reached();
2130     }
2131     qobject_unref(crumpled);
2132 }
2133
2134 static void qemu_read_default_config_file(Error **errp)
2135 {
2136     ERRP_GUARD();
2137     int ret;
2138     g_autofree char *file = get_relocated_path(CONFIG_QEMU_CONFDIR "/qemu.conf");
2139
2140     ret = qemu_read_config_file(file, qemu_parse_config_group, errp);
2141     if (ret < 0) {
2142         if (ret == -ENOENT) {
2143             error_free(*errp);
2144             *errp = NULL;
2145         }
2146     }
2147 }
2148
2149 static void qemu_set_option(const char *str, Error **errp)
2150 {
2151     char group[64], id[64], arg[64];
2152     QemuOptsList *list;
2153     QemuOpts *opts;
2154     int rc, offset;
2155
2156     rc = sscanf(str, "%63[^.].%63[^.].%63[^=]%n", group, id, arg, &offset);
2157     if (rc < 3 || str[offset] != '=') {
2158         error_setg(errp, "can't parse: \"%s\"", str);
2159         return;
2160     }
2161
2162     if (!is_qemuopts_group(group)) {
2163         error_setg(errp, "-set is not supported with %s", group);
2164     } else {
2165         list = qemu_find_opts_err(group, errp);
2166         if (list) {
2167             opts = qemu_opts_find(list, id);
2168             if (!opts) {
2169                 error_setg(errp, "there is no %s \"%s\" defined", group, id);
2170                 return;
2171             }
2172             qemu_opt_set(opts, arg, str + offset + 1, errp);
2173         }
2174     }
2175 }
2176
2177 static void user_register_global_props(void)
2178 {
2179     qemu_opts_foreach(qemu_find_opts("global"),
2180                       global_init_func, NULL, NULL);
2181 }
2182
2183 static int do_configure_icount(void *opaque, QemuOpts *opts, Error **errp)
2184 {
2185     icount_configure(opts, errp);
2186     return 0;
2187 }
2188
2189 static int accelerator_set_property(void *opaque,
2190                                 const char *name, const char *value,
2191                                 Error **errp)
2192 {
2193     return object_parse_property_opt(opaque, name, value, "accel", errp);
2194 }
2195
2196 static int do_configure_accelerator(void *opaque, QemuOpts *opts, Error **errp)
2197 {
2198     bool *p_init_failed = opaque;
2199     const char *acc = qemu_opt_get(opts, "accel");
2200     AccelClass *ac = accel_find(acc);
2201     AccelState *accel;
2202     int ret;
2203     bool qtest_with_kvm;
2204
2205     if (!acc) {
2206         error_setg(errp, QERR_MISSING_PARAMETER, "accel");
2207         goto bad;
2208     }
2209
2210     qtest_with_kvm = g_str_equal(acc, "kvm") && qtest_chrdev != NULL;
2211
2212     if (!ac) {
2213         if (!qtest_with_kvm) {
2214             error_report("invalid accelerator %s", acc);
2215         }
2216         goto bad;
2217     }
2218     accel = ACCEL(object_new_with_class(OBJECT_CLASS(ac)));
2219     object_apply_compat_props(OBJECT(accel));
2220     qemu_opt_foreach(opts, accelerator_set_property,
2221                      accel,
2222                      &error_fatal);
2223
2224     ret = accel_init_machine(accel, current_machine);
2225     if (ret < 0) {
2226         if (!qtest_with_kvm || ret != -ENOENT) {
2227             error_report("failed to initialize %s: %s", acc, strerror(-ret));
2228         }
2229         goto bad;
2230     }
2231
2232     return 1;
2233
2234 bad:
2235     *p_init_failed = true;
2236     return 0;
2237 }
2238
2239 static void configure_accelerators(const char *progname)
2240 {
2241     bool init_failed = false;
2242
2243     qemu_opts_foreach(qemu_find_opts("icount"),
2244                       do_configure_icount, NULL, &error_fatal);
2245
2246     if (QTAILQ_EMPTY(&qemu_accel_opts.head)) {
2247         char **accel_list, **tmp;
2248
2249         if (accelerators == NULL) {
2250             /* Select the default accelerator */
2251             bool have_tcg = accel_find("tcg");
2252             bool have_kvm = accel_find("kvm");
2253
2254             if (have_tcg && have_kvm) {
2255                 if (g_str_has_suffix(progname, "kvm")) {
2256                     /* If the program name ends with "kvm", we prefer KVM */
2257                     accelerators = "kvm:tcg";
2258                 } else {
2259                     accelerators = "tcg:kvm";
2260                 }
2261             } else if (have_kvm) {
2262                 accelerators = "kvm";
2263             } else if (have_tcg) {
2264                 accelerators = "tcg";
2265             } else {
2266                 error_report("No accelerator selected and"
2267                              " no default accelerator available");
2268                 exit(1);
2269             }
2270         }
2271         accel_list = g_strsplit(accelerators, ":", 0);
2272
2273         for (tmp = accel_list; *tmp; tmp++) {
2274             /*
2275              * Filter invalid accelerators here, to prevent obscenities
2276              * such as "-machine accel=tcg,,thread=single".
2277              */
2278             if (accel_find(*tmp)) {
2279                 qemu_opts_parse_noisily(qemu_find_opts("accel"), *tmp, true);
2280             } else {
2281                 init_failed = true;
2282                 error_report("invalid accelerator %s", *tmp);
2283             }
2284         }
2285         g_strfreev(accel_list);
2286     } else {
2287         if (accelerators != NULL) {
2288             error_report("The -accel and \"-machine accel=\" options are incompatible");
2289             exit(1);
2290         }
2291     }
2292
2293     if (!qemu_opts_foreach(qemu_find_opts("accel"),
2294                            do_configure_accelerator, &init_failed, &error_fatal)) {
2295         if (!init_failed) {
2296             error_report("no accelerator found");
2297         }
2298         exit(1);
2299     }
2300
2301     if (init_failed && !qtest_chrdev) {
2302         error_report("falling back to %s", current_accel_name());
2303     }
2304
2305     if (icount_enabled() && !tcg_enabled()) {
2306         error_report("-icount is not allowed with hardware virtualization");
2307         exit(1);
2308     }
2309 }
2310
2311 static void qemu_validate_options(const QDict *machine_opts)
2312 {
2313     const char *kernel_filename = qdict_get_try_str(machine_opts, "kernel");
2314     const char *initrd_filename = qdict_get_try_str(machine_opts, "initrd");
2315     const char *kernel_cmdline = qdict_get_try_str(machine_opts, "append");
2316
2317     if (kernel_filename == NULL) {
2318          if (kernel_cmdline != NULL) {
2319               error_report("-append only allowed with -kernel option");
2320               exit(1);
2321           }
2322
2323           if (initrd_filename != NULL) {
2324               error_report("-initrd only allowed with -kernel option");
2325               exit(1);
2326           }
2327     }
2328
2329     if (loadvm && preconfig_requested) {
2330         error_report("'preconfig' and 'loadvm' options are "
2331                      "mutually exclusive");
2332         exit(EXIT_FAILURE);
2333     }
2334     if (incoming && preconfig_requested && strcmp(incoming, "defer") != 0) {
2335         error_report("'preconfig' supports '-incoming defer' only");
2336         exit(EXIT_FAILURE);
2337     }
2338
2339 #ifdef CONFIG_CURSES
2340     if (is_daemonized() && dpy.type == DISPLAY_TYPE_CURSES) {
2341         error_report("curses display cannot be used with -daemonize");
2342         exit(1);
2343     }
2344 #endif
2345 }
2346
2347 static void qemu_process_sugar_options(void)
2348 {
2349     if (mem_prealloc) {
2350         QObject *smp = qdict_get(machine_opts_dict, "smp");
2351         if (smp && qobject_type(smp) == QTYPE_QDICT) {
2352             QObject *cpus = qdict_get(qobject_to(QDict, smp), "cpus");
2353             if (cpus && qobject_type(cpus) == QTYPE_QSTRING) {
2354                 const char *val = qstring_get_str(qobject_to(QString, cpus));
2355                 object_register_sugar_prop("memory-backend", "prealloc-threads",
2356                                            val, false);
2357             }
2358         }
2359         object_register_sugar_prop("memory-backend", "prealloc", "on", false);
2360     }
2361 }
2362
2363 /* -action processing */
2364
2365 /*
2366  * Process all the -action parameters parsed from cmdline.
2367  */
2368 static int process_runstate_actions(void *opaque, QemuOpts *opts, Error **errp)
2369 {
2370     Error *local_err = NULL;
2371     QDict *qdict = qemu_opts_to_qdict(opts, NULL);
2372     QObject *ret = NULL;
2373     qmp_marshal_set_action(qdict, &ret, &local_err);
2374     qobject_unref(ret);
2375     qobject_unref(qdict);
2376     if (local_err) {
2377         error_propagate(errp, local_err);
2378         return 1;
2379     }
2380     return 0;
2381 }
2382
2383 static void qemu_process_early_options(void)
2384 {
2385     qemu_opts_foreach(qemu_find_opts("name"),
2386                       parse_name, NULL, &error_fatal);
2387
2388     object_option_foreach_add(object_create_pre_sandbox);
2389
2390 #ifdef CONFIG_SECCOMP
2391     QemuOptsList *olist = qemu_find_opts_err("sandbox", NULL);
2392     if (olist) {
2393         qemu_opts_foreach(olist, parse_sandbox, NULL, &error_fatal);
2394     }
2395 #endif
2396
2397     if (qemu_opts_foreach(qemu_find_opts("action"),
2398                           process_runstate_actions, NULL, &error_fatal)) {
2399         exit(1);
2400     }
2401
2402 #ifndef _WIN32
2403     qemu_opts_foreach(qemu_find_opts("add-fd"),
2404                       parse_add_fd, NULL, &error_fatal);
2405
2406     qemu_opts_foreach(qemu_find_opts("add-fd"),
2407                       cleanup_add_fd, NULL, &error_fatal);
2408 #endif
2409
2410     /* Open the logfile at this point and set the log mask if necessary.  */
2411     {
2412         int mask = 0;
2413         if (log_mask) {
2414             mask = qemu_str_to_log_mask(log_mask);
2415             if (!mask) {
2416                 qemu_print_log_usage(stdout);
2417                 exit(1);
2418             }
2419         }
2420         qemu_set_log_filename_flags(log_file, mask, &error_fatal);
2421     }
2422
2423     qemu_add_default_firmwarepath();
2424 }
2425
2426 static void qemu_process_help_options(void)
2427 {
2428     /*
2429      * Check for -cpu help and -device help before we call select_machine(),
2430      * which will return an error if the architecture has no default machine
2431      * type and the user did not specify one, so that the user doesn't need
2432      * to say '-cpu help -machine something'.
2433      */
2434     if (cpu_option && is_help_option(cpu_option)) {
2435         list_cpus(cpu_option);
2436         exit(0);
2437     }
2438
2439     if (qemu_opts_foreach(qemu_find_opts("device"),
2440                           device_help_func, NULL, NULL)) {
2441         exit(0);
2442     }
2443
2444     /* -L help lists the data directories and exits. */
2445     if (list_data_dirs) {
2446         qemu_list_data_dirs();
2447         exit(0);
2448     }
2449 }
2450
2451 static void qemu_maybe_daemonize(const char *pid_file)
2452 {
2453     Error *err = NULL;
2454
2455     os_daemonize();
2456     rcu_disable_atfork();
2457
2458     if (pid_file) {
2459         char *pid_file_realpath = NULL;
2460
2461         if (!qemu_write_pidfile(pid_file, &err)) {
2462             error_reportf_err(err, "cannot create PID file: ");
2463             exit(1);
2464         }
2465
2466         pid_file_realpath = g_malloc0(PATH_MAX);
2467         if (!realpath(pid_file, pid_file_realpath)) {
2468             if (errno != ENOENT) {
2469                 warn_report("not removing PID file on exit: cannot resolve PID "
2470                             "file path: %s: %s", pid_file, strerror(errno));
2471             }
2472             return;
2473         }
2474
2475         qemu_unlink_pidfile_notifier = (struct UnlinkPidfileNotifier) {
2476             .notifier = {
2477                 .notify = qemu_unlink_pidfile,
2478             },
2479             .pid_file_realpath = pid_file_realpath,
2480         };
2481         qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier.notifier);
2482     }
2483 }
2484
2485 static void qemu_init_displays(void)
2486 {
2487     DisplayState *ds;
2488
2489     /* init local displays */
2490     ds = init_displaystate();
2491     qemu_display_init(ds, &dpy);
2492
2493     /* must be after terminal init, SDL library changes signal handlers */
2494     os_setup_signal_handling();
2495
2496     /* init remote displays */
2497 #ifdef CONFIG_VNC
2498     qemu_opts_foreach(qemu_find_opts("vnc"),
2499                       vnc_init_func, NULL, &error_fatal);
2500 #endif
2501
2502     if (using_spice) {
2503         qemu_spice.display_init();
2504     }
2505 }
2506
2507 static void qemu_init_board(void)
2508 {
2509     /* process plugin before CPUs are created, but once -smp has been parsed */
2510     qemu_plugin_load_list(&plugin_list, &error_fatal);
2511
2512     /* From here on we enter MACHINE_PHASE_INITIALIZED.  */
2513     machine_run_board_init(current_machine, mem_path, &error_fatal);
2514
2515     drive_check_orphaned();
2516
2517     realtime_init();
2518
2519     if (hax_enabled()) {
2520         /* FIXME: why isn't cpu_synchronize_all_post_init enough? */
2521         hax_sync_vcpus();
2522     }
2523 }
2524
2525 static void qemu_create_cli_devices(void)
2526 {
2527     DeviceOption *opt;
2528
2529     soundhw_init();
2530
2531     qemu_opts_foreach(qemu_find_opts("fw_cfg"),
2532                       parse_fw_cfg, fw_cfg_find(), &error_fatal);
2533
2534     /* init USB devices */
2535     if (machine_usb(current_machine)) {
2536         if (foreach_device_config(DEV_USB, usb_parse) < 0)
2537             exit(1);
2538     }
2539
2540     /* init generic devices */
2541     rom_set_order_override(FW_CFG_ORDER_OVERRIDE_DEVICE);
2542     qemu_opts_foreach(qemu_find_opts("device"),
2543                       device_init_func, NULL, &error_fatal);
2544     QTAILQ_FOREACH(opt, &device_opts, next) {
2545         DeviceState *dev;
2546         loc_push_restore(&opt->loc);
2547         /*
2548          * TODO Eventually we should call qmp_device_add() here to make sure it
2549          * behaves the same, but QMP still has to accept incorrectly typed
2550          * options until libvirt is fixed and we want to be strict on the CLI
2551          * from the start, so call qdev_device_add_from_qdict() directly for
2552          * now.
2553          */
2554         dev = qdev_device_add_from_qdict(opt->opts, true, &error_fatal);
2555         object_unref(OBJECT(dev));
2556         loc_pop(&opt->loc);
2557     }
2558     rom_reset_order_override();
2559 }
2560
2561 static void qemu_machine_creation_done(void)
2562 {
2563     MachineState *machine = MACHINE(qdev_get_machine());
2564
2565     /* Did we create any drives that we failed to create a device for? */
2566     drive_check_orphaned();
2567
2568     /* Don't warn about the default network setup that you get if
2569      * no command line -net or -netdev options are specified. There
2570      * are two cases that we would otherwise complain about:
2571      * (1) board doesn't support a NIC but the implicit "-net nic"
2572      * requested one
2573      * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
2574      * sets up a nic that isn't connected to anything.
2575      */
2576     if (!default_net && (!qtest_enabled() || has_defaults)) {
2577         net_check_clients();
2578     }
2579
2580     qdev_prop_check_globals();
2581
2582     qdev_machine_creation_done();
2583
2584     if (machine->cgs) {
2585         /*
2586          * Verify that Confidential Guest Support has actually been initialized
2587          */
2588         assert(machine->cgs->ready);
2589     }
2590
2591     if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) {
2592         exit(1);
2593     }
2594     if (!vga_interface_created && !default_vga &&
2595         vga_interface_type != VGA_NONE) {
2596         warn_report("A -vga option was passed but this machine "
2597                     "type does not use that option; "
2598                     "No VGA device has been created");
2599     }
2600 }
2601
2602 void qmp_x_exit_preconfig(Error **errp)
2603 {
2604     if (phase_check(PHASE_MACHINE_INITIALIZED)) {
2605         error_setg(errp, "The command is permitted only before machine initialization");
2606         return;
2607     }
2608
2609     qemu_init_board();
2610     qemu_create_cli_devices();
2611     qemu_machine_creation_done();
2612
2613     if (loadvm) {
2614         load_snapshot(loadvm, NULL, false, NULL, &error_fatal);
2615     }
2616     if (replay_mode != REPLAY_MODE_NONE) {
2617         replay_vmstate_init();
2618     }
2619
2620     if (incoming) {
2621         Error *local_err = NULL;
2622         if (strcmp(incoming, "defer") != 0) {
2623             qmp_migrate_incoming(incoming, &local_err);
2624             if (local_err) {
2625                 error_reportf_err(local_err, "-incoming %s: ", incoming);
2626                 exit(1);
2627             }
2628         }
2629     } else if (autostart) {
2630         qmp_cont(NULL);
2631     }
2632 }
2633
2634 void qemu_init(int argc, char **argv)
2635 {
2636     QemuOpts *opts;
2637     QemuOpts *icount_opts = NULL, *accel_opts = NULL;
2638     QemuOptsList *olist;
2639     int optind;
2640     const char *optarg;
2641     MachineClass *machine_class;
2642     bool userconfig = true;
2643     FILE *vmstate_dump_file = NULL;
2644
2645     qemu_add_opts(&qemu_drive_opts);
2646     qemu_add_drive_opts(&qemu_legacy_drive_opts);
2647     qemu_add_drive_opts(&qemu_common_drive_opts);
2648     qemu_add_drive_opts(&qemu_drive_opts);
2649     qemu_add_drive_opts(&bdrv_runtime_opts);
2650     qemu_add_opts(&qemu_chardev_opts);
2651     qemu_add_opts(&qemu_device_opts);
2652     qemu_add_opts(&qemu_netdev_opts);
2653     qemu_add_opts(&qemu_nic_opts);
2654     qemu_add_opts(&qemu_net_opts);
2655     qemu_add_opts(&qemu_rtc_opts);
2656     qemu_add_opts(&qemu_global_opts);
2657     qemu_add_opts(&qemu_mon_opts);
2658     qemu_add_opts(&qemu_trace_opts);
2659     qemu_plugin_add_opts();
2660     qemu_add_opts(&qemu_option_rom_opts);
2661     qemu_add_opts(&qemu_accel_opts);
2662     qemu_add_opts(&qemu_mem_opts);
2663     qemu_add_opts(&qemu_smp_opts);
2664     qemu_add_opts(&qemu_boot_opts);
2665     qemu_add_opts(&qemu_add_fd_opts);
2666     qemu_add_opts(&qemu_object_opts);
2667     qemu_add_opts(&qemu_tpmdev_opts);
2668     qemu_add_opts(&qemu_overcommit_opts);
2669     qemu_add_opts(&qemu_msg_opts);
2670     qemu_add_opts(&qemu_name_opts);
2671     qemu_add_opts(&qemu_numa_opts);
2672     qemu_add_opts(&qemu_icount_opts);
2673     qemu_add_opts(&qemu_semihosting_config_opts);
2674     qemu_add_opts(&qemu_fw_cfg_opts);
2675     qemu_add_opts(&qemu_action_opts);
2676     module_call_init(MODULE_INIT_OPTS);
2677
2678     error_init(argv[0]);
2679     qemu_init_exec_dir(argv[0]);
2680
2681     qemu_init_arch_modules();
2682
2683     qemu_init_subsystems();
2684
2685     /* first pass of option parsing */
2686     optind = 1;
2687     while (optind < argc) {
2688         if (argv[optind][0] != '-') {
2689             /* disk image */
2690             optind++;
2691         } else {
2692             const QEMUOption *popt;
2693
2694             popt = lookup_opt(argc, argv, &optarg, &optind);
2695             switch (popt->index) {
2696             case QEMU_OPTION_nouserconfig:
2697                 userconfig = false;
2698                 break;
2699             }
2700         }
2701     }
2702
2703     machine_opts_dict = qdict_new();
2704     if (userconfig) {
2705         qemu_read_default_config_file(&error_fatal);
2706     }
2707
2708     /* second pass of option parsing */
2709     optind = 1;
2710     for(;;) {
2711         if (optind >= argc)
2712             break;
2713         if (argv[optind][0] != '-') {
2714             loc_set_cmdline(argv, optind, 1);
2715             drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
2716         } else {
2717             const QEMUOption *popt;
2718
2719             popt = lookup_opt(argc, argv, &optarg, &optind);
2720             if (!(popt->arch_mask & arch_type)) {
2721                 error_report("Option not supported for this target");
2722                 exit(1);
2723             }
2724             switch(popt->index) {
2725             case QEMU_OPTION_cpu:
2726                 /* hw initialization will check this */
2727                 cpu_option = optarg;
2728                 break;
2729             case QEMU_OPTION_hda:
2730             case QEMU_OPTION_hdb:
2731             case QEMU_OPTION_hdc:
2732             case QEMU_OPTION_hdd:
2733                 drive_add(IF_DEFAULT, popt->index - QEMU_OPTION_hda, optarg,
2734                           HD_OPTS);
2735                 break;
2736             case QEMU_OPTION_blockdev:
2737                 {
2738                     Visitor *v;
2739                     BlockdevOptionsQueueEntry *bdo;
2740
2741                     v = qobject_input_visitor_new_str(optarg, "driver",
2742                                                       &error_fatal);
2743
2744                     bdo = g_new(BlockdevOptionsQueueEntry, 1);
2745                     visit_type_BlockdevOptions(v, NULL, &bdo->bdo,
2746                                                &error_fatal);
2747                     visit_free(v);
2748                     loc_save(&bdo->loc);
2749                     QSIMPLEQ_INSERT_TAIL(&bdo_queue, bdo, entry);
2750                     break;
2751                 }
2752             case QEMU_OPTION_drive:
2753                 opts = qemu_opts_parse_noisily(qemu_find_opts("drive"),
2754                                                optarg, false);
2755                 if (opts == NULL) {
2756                     exit(1);
2757                 }
2758                 break;
2759             case QEMU_OPTION_set:
2760                 qemu_set_option(optarg, &error_fatal);
2761                 break;
2762             case QEMU_OPTION_global:
2763                 if (qemu_global_option(optarg) != 0)
2764                     exit(1);
2765                 break;
2766             case QEMU_OPTION_mtdblock:
2767                 drive_add(IF_MTD, -1, optarg, MTD_OPTS);
2768                 break;
2769             case QEMU_OPTION_sd:
2770                 drive_add(IF_SD, -1, optarg, SD_OPTS);
2771                 break;
2772             case QEMU_OPTION_pflash:
2773                 drive_add(IF_PFLASH, -1, optarg, PFLASH_OPTS);
2774                 break;
2775             case QEMU_OPTION_snapshot:
2776                 snapshot = 1;
2777                 replay_add_blocker("-snapshot");
2778                 break;
2779             case QEMU_OPTION_numa:
2780                 opts = qemu_opts_parse_noisily(qemu_find_opts("numa"),
2781                                                optarg, true);
2782                 if (!opts) {
2783                     exit(1);
2784                 }
2785                 break;
2786             case QEMU_OPTION_display:
2787                 parse_display(optarg);
2788                 break;
2789             case QEMU_OPTION_nographic:
2790                 qdict_put_str(machine_opts_dict, "graphics", "off");
2791                 nographic = true;
2792                 dpy.type = DISPLAY_TYPE_NONE;
2793                 break;
2794             case QEMU_OPTION_portrait:
2795                 graphic_rotate = 90;
2796                 break;
2797             case QEMU_OPTION_rotate:
2798                 graphic_rotate = strtol(optarg, (char **) &optarg, 10);
2799                 if (graphic_rotate != 0 && graphic_rotate != 90 &&
2800                     graphic_rotate != 180 && graphic_rotate != 270) {
2801                     error_report("only 90, 180, 270 deg rotation is available");
2802                     exit(1);
2803                 }
2804                 break;
2805             case QEMU_OPTION_kernel:
2806                 qdict_put_str(machine_opts_dict, "kernel", optarg);
2807                 break;
2808             case QEMU_OPTION_initrd:
2809                 qdict_put_str(machine_opts_dict, "initrd", optarg);
2810                 break;
2811             case QEMU_OPTION_append:
2812                 qdict_put_str(machine_opts_dict, "append", optarg);
2813                 break;
2814             case QEMU_OPTION_dtb:
2815                 qdict_put_str(machine_opts_dict, "dtb", optarg);
2816                 break;
2817             case QEMU_OPTION_cdrom:
2818                 drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS);
2819                 break;
2820             case QEMU_OPTION_boot:
2821                 machine_parse_property_opt(qemu_find_opts("boot-opts"), "boot", optarg);
2822                 break;
2823             case QEMU_OPTION_fda:
2824             case QEMU_OPTION_fdb:
2825                 drive_add(IF_FLOPPY, popt->index - QEMU_OPTION_fda,
2826                           optarg, FD_OPTS);
2827                 break;
2828             case QEMU_OPTION_no_fd_bootchk:
2829                 fd_bootchk = 0;
2830                 break;
2831             case QEMU_OPTION_netdev:
2832                 default_net = 0;
2833                 if (netdev_is_modern(optarg)) {
2834                     netdev_parse_modern(optarg);
2835                 } else {
2836                     net_client_parse(qemu_find_opts("netdev"), optarg);
2837                 }
2838                 break;
2839             case QEMU_OPTION_nic:
2840                 default_net = 0;
2841                 net_client_parse(qemu_find_opts("nic"), optarg);
2842                 break;
2843             case QEMU_OPTION_net:
2844                 default_net = 0;
2845                 net_client_parse(qemu_find_opts("net"), optarg);
2846                 break;
2847 #ifdef CONFIG_LIBISCSI
2848             case QEMU_OPTION_iscsi:
2849                 opts = qemu_opts_parse_noisily(qemu_find_opts("iscsi"),
2850                                                optarg, false);
2851                 if (!opts) {
2852                     exit(1);
2853                 }
2854                 break;
2855 #endif
2856             case QEMU_OPTION_audio_help:
2857                 audio_legacy_help();
2858                 exit (0);
2859                 break;
2860             case QEMU_OPTION_audiodev:
2861                 audio_parse_option(optarg);
2862                 break;
2863             case QEMU_OPTION_audio: {
2864                 bool help;
2865                 char *model;
2866                 Audiodev *dev = NULL;
2867                 Visitor *v;
2868                 QDict *dict = keyval_parse(optarg, "driver", &help, &error_fatal);
2869                 if (help || (qdict_haskey(dict, "driver") &&
2870                              is_help_option(qdict_get_str(dict, "driver")))) {
2871                     audio_help();
2872                     exit(EXIT_SUCCESS);
2873                 }
2874                 if (!qdict_haskey(dict, "id")) {
2875                     qdict_put_str(dict, "id", "audiodev0");
2876                 }
2877                 if (!qdict_haskey(dict, "model")) {
2878                     error_setg(&error_fatal, "Parameter 'model' is missing");
2879                 }
2880                 model = g_strdup(qdict_get_str(dict, "model"));
2881                 qdict_del(dict, "model");
2882                 if (is_help_option(model)) {
2883                     show_valid_soundhw();
2884                     exit(0);
2885                 }
2886                 v = qobject_input_visitor_new_keyval(QOBJECT(dict));
2887                 qobject_unref(dict);
2888                 visit_type_Audiodev(v, NULL, &dev, &error_fatal);
2889                 visit_free(v);
2890                 audio_define(dev);
2891                 select_soundhw(model, dev->id);
2892                 g_free(model);
2893                 break;
2894             }
2895             case QEMU_OPTION_h:
2896                 help(0);
2897                 break;
2898             case QEMU_OPTION_version:
2899                 version();
2900                 exit(0);
2901                 break;
2902             case QEMU_OPTION_m:
2903                 opts = qemu_opts_parse_noisily(qemu_find_opts("memory"), optarg, true);
2904                 if (opts == NULL) {
2905                     exit(1);
2906                 }
2907                 break;
2908 #ifdef CONFIG_TPM
2909             case QEMU_OPTION_tpmdev:
2910                 if (tpm_config_parse(qemu_find_opts("tpmdev"), optarg) < 0) {
2911                     exit(1);
2912                 }
2913                 break;
2914 #endif
2915             case QEMU_OPTION_mempath:
2916                 mem_path = optarg;
2917                 break;
2918             case QEMU_OPTION_mem_prealloc:
2919                 mem_prealloc = 1;
2920                 break;
2921             case QEMU_OPTION_d:
2922                 log_mask = optarg;
2923                 break;
2924             case QEMU_OPTION_D:
2925                 log_file = optarg;
2926                 break;
2927             case QEMU_OPTION_DFILTER:
2928                 qemu_set_dfilter_ranges(optarg, &error_fatal);
2929                 break;
2930 #if defined(CONFIG_TCG) && defined(CONFIG_LINUX)
2931             case QEMU_OPTION_perfmap:
2932                 perf_enable_perfmap();
2933                 break;
2934             case QEMU_OPTION_jitdump:
2935                 perf_enable_jitdump();
2936                 break;
2937 #endif
2938             case QEMU_OPTION_seed:
2939                 qemu_guest_random_seed_main(optarg, &error_fatal);
2940                 break;
2941             case QEMU_OPTION_s:
2942                 add_device_config(DEV_GDB, "tcp::" DEFAULT_GDBSTUB_PORT);
2943                 break;
2944             case QEMU_OPTION_gdb:
2945                 add_device_config(DEV_GDB, optarg);
2946                 break;
2947             case QEMU_OPTION_L:
2948                 if (is_help_option(optarg)) {
2949                     list_data_dirs = true;
2950                 } else {
2951                     qemu_add_data_dir(g_strdup(optarg));
2952                 }
2953                 break;
2954             case QEMU_OPTION_bios:
2955                 qdict_put_str(machine_opts_dict, "firmware", optarg);
2956                 break;
2957             case QEMU_OPTION_singlestep:
2958                 singlestep = 1;
2959                 break;
2960             case QEMU_OPTION_S:
2961                 autostart = 0;
2962                 break;
2963             case QEMU_OPTION_k:
2964                 keyboard_layout = optarg;
2965                 break;
2966             case QEMU_OPTION_vga:
2967                 vga_model = optarg;
2968                 default_vga = 0;
2969                 break;
2970             case QEMU_OPTION_g:
2971                 {
2972                     const char *p;
2973                     int w, h, depth;
2974                     p = optarg;
2975                     w = strtol(p, (char **)&p, 10);
2976                     if (w <= 0) {
2977                     graphic_error:
2978                         error_report("invalid resolution or depth");
2979                         exit(1);
2980                     }
2981                     if (*p != 'x')
2982                         goto graphic_error;
2983                     p++;
2984                     h = strtol(p, (char **)&p, 10);
2985                     if (h <= 0)
2986                         goto graphic_error;
2987                     if (*p == 'x') {
2988                         p++;
2989                         depth = strtol(p, (char **)&p, 10);
2990                         if (depth != 1 && depth != 2 && depth != 4 &&
2991                             depth != 8 && depth != 15 && depth != 16 &&
2992                             depth != 24 && depth != 32)
2993                             goto graphic_error;
2994                     } else if (*p == '\0') {
2995                         depth = graphic_depth;
2996                     } else {
2997                         goto graphic_error;
2998                     }
2999
3000                     graphic_width = w;
3001                     graphic_height = h;
3002                     graphic_depth = depth;
3003                 }
3004                 break;
3005             case QEMU_OPTION_echr:
3006                 {
3007                     char *r;
3008                     term_escape_char = strtol(optarg, &r, 0);
3009                     if (r == optarg)
3010                         printf("Bad argument to echr\n");
3011                     break;
3012                 }
3013             case QEMU_OPTION_monitor:
3014                 default_monitor = 0;
3015                 if (strncmp(optarg, "none", 4)) {
3016                     monitor_parse(optarg, "readline", false);
3017                 }
3018                 break;
3019             case QEMU_OPTION_qmp:
3020                 monitor_parse(optarg, "control", false);
3021                 default_monitor = 0;
3022                 break;
3023             case QEMU_OPTION_qmp_pretty:
3024                 monitor_parse(optarg, "control", true);
3025                 default_monitor = 0;
3026                 break;
3027             case QEMU_OPTION_mon:
3028                 opts = qemu_opts_parse_noisily(qemu_find_opts("mon"), optarg,
3029                                                true);
3030                 if (!opts) {
3031                     exit(1);
3032                 }
3033                 default_monitor = 0;
3034                 break;
3035             case QEMU_OPTION_chardev:
3036                 opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
3037                                                optarg, true);
3038                 if (!opts) {
3039                     exit(1);
3040                 }
3041                 break;
3042             case QEMU_OPTION_fsdev:
3043                 olist = qemu_find_opts("fsdev");
3044                 if (!olist) {
3045                     error_report("fsdev support is disabled");
3046                     exit(1);
3047                 }
3048                 opts = qemu_opts_parse_noisily(olist, optarg, true);
3049                 if (!opts) {
3050                     exit(1);
3051                 }
3052                 break;
3053             case QEMU_OPTION_virtfs: {
3054                 QemuOpts *fsdev;
3055                 QemuOpts *device;
3056                 const char *writeout, *sock_fd, *socket, *path, *security_model,
3057                            *multidevs;
3058
3059                 olist = qemu_find_opts("virtfs");
3060                 if (!olist) {
3061                     error_report("virtfs support is disabled");
3062                     exit(1);
3063                 }
3064                 opts = qemu_opts_parse_noisily(olist, optarg, true);
3065                 if (!opts) {
3066                     exit(1);
3067                 }
3068
3069                 if (qemu_opt_get(opts, "fsdriver") == NULL ||
3070                     qemu_opt_get(opts, "mount_tag") == NULL) {
3071                     error_report("Usage: -virtfs fsdriver,mount_tag=tag");
3072                     exit(1);
3073                 }
3074                 fsdev = qemu_opts_create(qemu_find_opts("fsdev"),
3075                                          qemu_opts_id(opts) ?:
3076                                          qemu_opt_get(opts, "mount_tag"),
3077                                          1, NULL);
3078                 if (!fsdev) {
3079                     error_report("duplicate or invalid fsdev id: %s",
3080                                  qemu_opt_get(opts, "mount_tag"));
3081                     exit(1);
3082                 }
3083
3084                 writeout = qemu_opt_get(opts, "writeout");
3085                 if (writeout) {
3086 #ifdef CONFIG_SYNC_FILE_RANGE
3087                     qemu_opt_set(fsdev, "writeout", writeout, &error_abort);
3088 #else
3089                     error_report("writeout=immediate not supported "
3090                                  "on this platform");
3091                     exit(1);
3092 #endif
3093                 }
3094                 qemu_opt_set(fsdev, "fsdriver",
3095                              qemu_opt_get(opts, "fsdriver"), &error_abort);
3096                 path = qemu_opt_get(opts, "path");
3097                 if (path) {
3098                     qemu_opt_set(fsdev, "path", path, &error_abort);
3099                 }
3100                 security_model = qemu_opt_get(opts, "security_model");
3101                 if (security_model) {
3102                     qemu_opt_set(fsdev, "security_model", security_model,
3103                                  &error_abort);
3104                 }
3105                 socket = qemu_opt_get(opts, "socket");
3106                 if (socket) {
3107                     qemu_opt_set(fsdev, "socket", socket, &error_abort);
3108                 }
3109                 sock_fd = qemu_opt_get(opts, "sock_fd");
3110                 if (sock_fd) {
3111                     qemu_opt_set(fsdev, "sock_fd", sock_fd, &error_abort);
3112                 }
3113
3114                 qemu_opt_set_bool(fsdev, "readonly",
3115                                   qemu_opt_get_bool(opts, "readonly", 0),
3116                                   &error_abort);
3117                 multidevs = qemu_opt_get(opts, "multidevs");
3118                 if (multidevs) {
3119                     qemu_opt_set(fsdev, "multidevs", multidevs, &error_abort);
3120                 }
3121                 device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
3122                                           &error_abort);
3123                 qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
3124                 qemu_opt_set(device, "fsdev",
3125                              qemu_opts_id(fsdev), &error_abort);
3126                 qemu_opt_set(device, "mount_tag",
3127                              qemu_opt_get(opts, "mount_tag"), &error_abort);
3128                 break;
3129             }
3130             case QEMU_OPTION_serial:
3131                 add_device_config(DEV_SERIAL, optarg);
3132                 default_serial = 0;
3133                 if (strncmp(optarg, "mon:", 4) == 0) {
3134                     default_monitor = 0;
3135                 }
3136                 break;
3137             case QEMU_OPTION_action:
3138                 olist = qemu_find_opts("action");
3139                 if (!qemu_opts_parse_noisily(olist, optarg, false)) {
3140                      exit(1);
3141                 }
3142                 break;
3143             case QEMU_OPTION_watchdog_action: {
3144                 QemuOpts *opts;
3145                 opts = qemu_opts_create(qemu_find_opts("action"), NULL, 0, &error_abort);
3146                 qemu_opt_set(opts, "watchdog", optarg, &error_abort);
3147                 break;
3148             }
3149             case QEMU_OPTION_parallel:
3150                 add_device_config(DEV_PARALLEL, optarg);
3151                 default_parallel = 0;
3152                 if (strncmp(optarg, "mon:", 4) == 0) {
3153                     default_monitor = 0;
3154                 }
3155                 break;
3156             case QEMU_OPTION_debugcon:
3157                 add_device_config(DEV_DEBUGCON, optarg);
3158                 break;
3159             case QEMU_OPTION_loadvm:
3160                 loadvm = optarg;
3161                 break;
3162             case QEMU_OPTION_full_screen:
3163                 dpy.has_full_screen = true;
3164                 dpy.full_screen = true;
3165                 break;
3166             case QEMU_OPTION_pidfile:
3167                 pid_file = optarg;
3168                 break;
3169             case QEMU_OPTION_win2k_hack:
3170                 win2k_install_hack = 1;
3171                 break;
3172             case QEMU_OPTION_acpitable:
3173                 opts = qemu_opts_parse_noisily(qemu_find_opts("acpi"),
3174                                                optarg, true);
3175                 if (!opts) {
3176                     exit(1);
3177                 }
3178                 acpi_table_add(opts, &error_fatal);
3179                 break;
3180             case QEMU_OPTION_smbios:
3181                 opts = qemu_opts_parse_noisily(qemu_find_opts("smbios"),
3182                                                optarg, false);
3183                 if (!opts) {
3184                     exit(1);
3185                 }
3186                 smbios_entry_add(opts, &error_fatal);
3187                 break;
3188             case QEMU_OPTION_fwcfg:
3189                 opts = qemu_opts_parse_noisily(qemu_find_opts("fw_cfg"),
3190                                                optarg, true);
3191                 if (opts == NULL) {
3192                     exit(1);
3193                 }
3194                 break;
3195             case QEMU_OPTION_preconfig:
3196                 preconfig_requested = true;
3197                 break;
3198             case QEMU_OPTION_enable_kvm:
3199                 qdict_put_str(machine_opts_dict, "accel", "kvm");
3200                 break;
3201             case QEMU_OPTION_M:
3202             case QEMU_OPTION_machine:
3203                 {
3204                     bool help;
3205
3206                     keyval_parse_into(machine_opts_dict, optarg, "type", &help, &error_fatal);
3207                     if (help) {
3208                         machine_help_func(machine_opts_dict);
3209                         exit(EXIT_SUCCESS);
3210                     }
3211                     break;
3212                 }
3213             case QEMU_OPTION_accel:
3214                 accel_opts = qemu_opts_parse_noisily(qemu_find_opts("accel"),
3215                                                      optarg, true);
3216                 optarg = qemu_opt_get(accel_opts, "accel");
3217                 if (!optarg || is_help_option(optarg)) {
3218                     printf("Accelerators supported in QEMU binary:\n");
3219                     GSList *el, *accel_list = object_class_get_list(TYPE_ACCEL,
3220                                                                     false);
3221                     for (el = accel_list; el; el = el->next) {
3222                         gchar *typename = g_strdup(object_class_get_name(
3223                                                    OBJECT_CLASS(el->data)));
3224                         /* omit qtest which is used for tests only */
3225                         if (g_strcmp0(typename, ACCEL_CLASS_NAME("qtest")) &&
3226                             g_str_has_suffix(typename, ACCEL_CLASS_SUFFIX)) {
3227                             gchar **optname = g_strsplit(typename,
3228                                                          ACCEL_CLASS_SUFFIX, 0);
3229                             printf("%s\n", optname[0]);
3230                             g_strfreev(optname);
3231                         }
3232                         g_free(typename);
3233                     }
3234                     g_slist_free(accel_list);
3235                     exit(0);
3236                 }
3237                 break;
3238             case QEMU_OPTION_usb:
3239                 qdict_put_str(machine_opts_dict, "usb", "on");
3240                 break;
3241             case QEMU_OPTION_usbdevice:
3242                 qdict_put_str(machine_opts_dict, "usb", "on");
3243                 add_device_config(DEV_USB, optarg);
3244                 break;
3245             case QEMU_OPTION_device:
3246                 if (optarg[0] == '{') {
3247                     QObject *obj = qobject_from_json(optarg, &error_fatal);
3248                     DeviceOption *opt = g_new0(DeviceOption, 1);
3249                     opt->opts = qobject_to(QDict, obj);
3250                     loc_save(&opt->loc);
3251                     assert(opt->opts != NULL);
3252                     QTAILQ_INSERT_TAIL(&device_opts, opt, next);
3253                 } else {
3254                     if (!qemu_opts_parse_noisily(qemu_find_opts("device"),
3255                                                  optarg, true)) {
3256                         exit(1);
3257                     }
3258                 }
3259                 break;
3260             case QEMU_OPTION_smp:
3261                 machine_parse_property_opt(qemu_find_opts("smp-opts"),
3262                                            "smp", optarg);
3263                 break;
3264             case QEMU_OPTION_vnc:
3265                 vnc_parse(optarg);
3266                 break;
3267             case QEMU_OPTION_no_acpi:
3268                 warn_report("-no-acpi is deprecated, use '-machine acpi=off' instead");
3269                 qdict_put_str(machine_opts_dict, "acpi", "off");
3270                 break;
3271             case QEMU_OPTION_no_hpet:
3272                 warn_report("-no-hpet is deprecated, use '-machine hpet=off' instead");
3273                 qdict_put_str(machine_opts_dict, "hpet", "off");
3274                 break;
3275             case QEMU_OPTION_no_reboot:
3276                 olist = qemu_find_opts("action");
3277                 qemu_opts_parse_noisily(olist, "reboot=shutdown", false);
3278                 break;
3279             case QEMU_OPTION_no_shutdown:
3280                 olist = qemu_find_opts("action");
3281                 qemu_opts_parse_noisily(olist, "shutdown=pause", false);
3282                 break;
3283             case QEMU_OPTION_uuid:
3284                 if (qemu_uuid_parse(optarg, &qemu_uuid) < 0) {
3285                     error_report("failed to parse UUID string: wrong format");
3286                     exit(1);
3287                 }
3288                 qemu_uuid_set = true;
3289                 break;
3290             case QEMU_OPTION_option_rom:
3291                 if (nb_option_roms >= MAX_OPTION_ROMS) {
3292                     error_report("too many option ROMs");
3293                     exit(1);
3294                 }
3295                 opts = qemu_opts_parse_noisily(qemu_find_opts("option-rom"),
3296                                                optarg, true);
3297                 if (!opts) {
3298                     exit(1);
3299                 }
3300                 option_rom[nb_option_roms].name = qemu_opt_get(opts, "romfile");
3301                 option_rom[nb_option_roms].bootindex =
3302                     qemu_opt_get_number(opts, "bootindex", -1);
3303                 if (!option_rom[nb_option_roms].name) {
3304                     error_report("Option ROM file is not specified");
3305                     exit(1);
3306                 }
3307                 nb_option_roms++;
3308                 break;
3309             case QEMU_OPTION_semihosting:
3310                 qemu_semihosting_enable();
3311                 break;
3312             case QEMU_OPTION_semihosting_config:
3313                 if (qemu_semihosting_config_options(optarg) != 0) {
3314                     exit(1);
3315                 }
3316                 break;
3317             case QEMU_OPTION_name:
3318                 opts = qemu_opts_parse_noisily(qemu_find_opts("name"),
3319                                                optarg, true);
3320                 if (!opts) {
3321                     exit(1);
3322                 }
3323                 /* Capture guest name if -msg guest-name is used later */
3324                 error_guest_name = qemu_opt_get(opts, "guest");
3325                 break;
3326             case QEMU_OPTION_prom_env:
3327                 if (nb_prom_envs >= MAX_PROM_ENVS) {
3328                     error_report("too many prom variables");
3329                     exit(1);
3330                 }
3331                 prom_envs[nb_prom_envs] = optarg;
3332                 nb_prom_envs++;
3333                 break;
3334             case QEMU_OPTION_old_param:
3335                 old_param = 1;
3336                 break;
3337             case QEMU_OPTION_rtc:
3338                 opts = qemu_opts_parse_noisily(qemu_find_opts("rtc"), optarg,
3339                                                false);
3340                 if (!opts) {
3341                     exit(1);
3342                 }
3343                 break;
3344             case QEMU_OPTION_icount:
3345                 icount_opts = qemu_opts_parse_noisily(qemu_find_opts("icount"),
3346                                                       optarg, true);
3347                 if (!icount_opts) {
3348                     exit(1);
3349                 }
3350                 break;
3351             case QEMU_OPTION_incoming:
3352                 if (!incoming) {
3353                     runstate_set(RUN_STATE_INMIGRATE);
3354                 }
3355                 incoming = optarg;
3356                 break;
3357             case QEMU_OPTION_only_migratable:
3358                 only_migratable = 1;
3359                 break;
3360             case QEMU_OPTION_nodefaults:
3361                 has_defaults = 0;
3362                 break;
3363             case QEMU_OPTION_xen_domid:
3364                 if (!(accel_find("xen")) && !(accel_find("kvm"))) {
3365                     error_report("Option not supported for this target");
3366                     exit(1);
3367                 }
3368                 xen_domid = atoi(optarg);
3369                 break;
3370             case QEMU_OPTION_xen_attach:
3371                 if (!(accel_find("xen"))) {
3372                     error_report("Option not supported for this target");
3373                     exit(1);
3374                 }
3375                 xen_mode = XEN_ATTACH;
3376                 break;
3377             case QEMU_OPTION_xen_domid_restrict:
3378                 if (!(accel_find("xen"))) {
3379                     error_report("Option not supported for this target");
3380                     exit(1);
3381                 }
3382                 xen_domid_restrict = true;
3383                 break;
3384             case QEMU_OPTION_trace:
3385                 trace_opt_parse(optarg);
3386                 break;
3387             case QEMU_OPTION_plugin:
3388                 qemu_plugin_opt_parse(optarg, &plugin_list);
3389                 break;
3390             case QEMU_OPTION_readconfig:
3391                 qemu_read_config_file(optarg, qemu_parse_config_group, &error_fatal);
3392                 break;
3393 #ifdef CONFIG_SPICE
3394             case QEMU_OPTION_spice:
3395                 olist = qemu_find_opts_err("spice", NULL);
3396                 if (!olist) {
3397                     error_report("spice support is disabled");
3398                     exit(1);
3399                 }
3400                 opts = qemu_opts_parse_noisily(olist, optarg, false);
3401                 if (!opts) {
3402                     exit(1);
3403                 }
3404                 display_remote++;
3405                 break;
3406 #endif
3407             case QEMU_OPTION_qtest:
3408                 qtest_chrdev = optarg;
3409                 break;
3410             case QEMU_OPTION_qtest_log:
3411                 qtest_log = optarg;
3412                 break;
3413             case QEMU_OPTION_sandbox:
3414                 olist = qemu_find_opts("sandbox");
3415                 if (!olist) {
3416 #ifndef CONFIG_SECCOMP
3417                     error_report("-sandbox support is not enabled "
3418                                  "in this QEMU binary");
3419 #endif
3420                     exit(1);
3421                 }
3422
3423                 opts = qemu_opts_parse_noisily(olist, optarg, true);
3424                 if (!opts) {
3425                     exit(1);
3426                 }
3427                 break;
3428             case QEMU_OPTION_add_fd:
3429 #ifndef _WIN32
3430                 opts = qemu_opts_parse_noisily(qemu_find_opts("add-fd"),
3431                                                optarg, false);
3432                 if (!opts) {
3433                     exit(1);
3434                 }
3435 #else
3436                 error_report("File descriptor passing is disabled on this "
3437                              "platform");
3438                 exit(1);
3439 #endif
3440                 break;
3441             case QEMU_OPTION_object:
3442                 object_option_parse(optarg);
3443                 break;
3444             case QEMU_OPTION_overcommit:
3445                 opts = qemu_opts_parse_noisily(qemu_find_opts("overcommit"),
3446                                                optarg, false);
3447                 if (!opts) {
3448                     exit(1);
3449                 }
3450                 enable_mlock = qemu_opt_get_bool(opts, "mem-lock", false);
3451                 enable_cpu_pm = qemu_opt_get_bool(opts, "cpu-pm", false);
3452                 break;
3453             case QEMU_OPTION_compat:
3454                 {
3455                     CompatPolicy *opts;
3456                     Visitor *v;
3457
3458                     v = qobject_input_visitor_new_str(optarg, NULL,
3459                                                       &error_fatal);
3460
3461                     visit_type_CompatPolicy(v, NULL, &opts, &error_fatal);
3462                     QAPI_CLONE_MEMBERS(CompatPolicy, &compat_policy, opts);
3463
3464                     qapi_free_CompatPolicy(opts);
3465                     visit_free(v);
3466                     break;
3467                 }
3468             case QEMU_OPTION_msg:
3469                 opts = qemu_opts_parse_noisily(qemu_find_opts("msg"), optarg,
3470                                                false);
3471                 if (!opts) {
3472                     exit(1);
3473                 }
3474                 configure_msg(opts);
3475                 break;
3476             case QEMU_OPTION_dump_vmstate:
3477                 if (vmstate_dump_file) {
3478                     error_report("only one '-dump-vmstate' "
3479                                  "option may be given");
3480                     exit(1);
3481                 }
3482                 vmstate_dump_file = fopen(optarg, "w");
3483                 if (vmstate_dump_file == NULL) {
3484                     error_report("open %s: %s", optarg, strerror(errno));
3485                     exit(1);
3486                 }
3487                 break;
3488             case QEMU_OPTION_enable_sync_profile:
3489                 qsp_enable();
3490                 break;
3491             case QEMU_OPTION_nouserconfig:
3492                 /* Nothing to be parsed here. Especially, do not error out below. */
3493                 break;
3494             default:
3495                 if (os_parse_cmd_args(popt->index, optarg)) {
3496                     error_report("Option not supported in this build");
3497                     exit(1);
3498                 }
3499             }
3500         }
3501     }
3502     /*
3503      * Clear error location left behind by the loop.
3504      * Best done right after the loop.  Do not insert code here!
3505      */
3506     loc_set_none();
3507
3508     qemu_validate_options(machine_opts_dict);
3509     qemu_process_sugar_options();
3510
3511     /*
3512      * These options affect everything else and should be processed
3513      * before daemonizing.
3514      */
3515     qemu_process_early_options();
3516
3517     qemu_process_help_options();
3518     qemu_maybe_daemonize(pid_file);
3519
3520     /*
3521      * The trace backend must be initialized after daemonizing.
3522      * trace_init_backends() will call st_init(), which will create the
3523      * trace thread in the parent, and also register st_flush_trace_buffer()
3524      * in atexit(). This function will force the parent to wait for the
3525      * writeout thread to finish, which will not occur, and the parent
3526      * process will be left in the host.
3527      */
3528     if (!trace_init_backends()) {
3529         exit(1);
3530     }
3531     trace_init_file();
3532
3533     qemu_init_main_loop(&error_fatal);
3534     cpu_timers_init();
3535
3536     user_register_global_props();
3537     replay_configure(icount_opts);
3538
3539     configure_rtc(qemu_find_opts_singleton("rtc"));
3540
3541     /* Transfer QemuOpts options into machine options */
3542     parse_memory_options();
3543
3544     qemu_create_machine(machine_opts_dict);
3545
3546     suspend_mux_open();
3547
3548     qemu_disable_default_devices();
3549     qemu_create_default_devices();
3550     qemu_create_early_backends();
3551
3552     qemu_apply_legacy_machine_options(machine_opts_dict);
3553     qemu_apply_machine_options(machine_opts_dict);
3554     qobject_unref(machine_opts_dict);
3555     phase_advance(PHASE_MACHINE_CREATED);
3556
3557     /*
3558      * Note: uses machine properties such as kernel-irqchip, must run
3559      * after qemu_apply_machine_options.
3560      */
3561     configure_accelerators(argv[0]);
3562     phase_advance(PHASE_ACCEL_CREATED);
3563
3564     /*
3565      * Beware, QOM objects created before this point miss global and
3566      * compat properties.
3567      *
3568      * Global properties get set up by qdev_prop_register_global(),
3569      * called from user_register_global_props(), and certain option
3570      * desugaring.  Also in CPU feature desugaring (buried in
3571      * parse_cpu_option()), which happens below this point, but may
3572      * only target the CPU type, which can only be created after
3573      * parse_cpu_option() returned the type.
3574      *
3575      * Machine compat properties: object_set_machine_compat_props().
3576      * Accelerator compat props: object_set_accelerator_compat_props(),
3577      * called from do_configure_accelerator().
3578      */
3579
3580     machine_class = MACHINE_GET_CLASS(current_machine);
3581     if (!qtest_enabled() && machine_class->deprecation_reason) {
3582         warn_report("Machine type '%s' is deprecated: %s",
3583                      machine_class->name, machine_class->deprecation_reason);
3584     }
3585
3586     /*
3587      * Note: creates a QOM object, must run only after global and
3588      * compat properties have been set up.
3589      */
3590     migration_object_init();
3591
3592     qemu_create_late_backends();
3593
3594     /* parse features once if machine provides default cpu_type */
3595     current_machine->cpu_type = machine_class->default_cpu_type;
3596     if (cpu_option) {
3597         current_machine->cpu_type = parse_cpu_option(cpu_option);
3598     }
3599     /* NB: for machine none cpu_type could STILL be NULL here! */
3600
3601     qemu_resolve_machine_memdev();
3602     parse_numa_opts(current_machine);
3603
3604     if (vmstate_dump_file) {
3605         /* dump and exit */
3606         module_load_qom_all();
3607         dump_vmstate_json_to_file(vmstate_dump_file);
3608         exit(0);
3609     }
3610
3611     if (!preconfig_requested) {
3612         qmp_x_exit_preconfig(&error_fatal);
3613     }
3614     qemu_init_displays();
3615     accel_setup_post(current_machine);
3616     os_setup_post();
3617     resume_mux_open();
3618 }