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
 100 #include "disas/disas.h"
 101
 102 #include "trace.h"
 103 #include "trace/control.h"
 104 #include "qemu/plugin.h"
 105 #include "qemu/queue.h"
 106 #include "sysemu/arch_init.h"
 107 #include "exec/confidential-guest-support.h"
 108
 109 #include "ui/qemu-spice.h"
 110 #include "qapi/string-input-visitor.h"
 111 #include "qapi/opts-visitor.h"
 112 #include "qapi/clone-visitor.h"
 113 #include "qom/object_interfaces.h"
 114 #include "semihosting/semihost.h"
 115 #include "crypto/init.h"
 116 #include "sysemu/replay.h"
 117 #include "qapi/qapi-events-run-state.h"
 118 #include "qapi/qapi-types-audio.h"
 119 #include "qapi/qapi-visit-audio.h"
 120 #include "qapi/qapi-visit-block-core.h"
 121 #include "qapi/qapi-visit-compat.h"
 122 #include "qapi/qapi-visit-machine.h"
 123 #include "qapi/qapi-visit-ui.h"
 124 #include "qapi/qapi-commands-block-core.h"
 125 #include "qapi/qapi-commands-migration.h"
 126 #include "qapi/qapi-commands-misc.h"
 127 #include "qapi/qapi-visit-qom.h"
 128 #include "qapi/qapi-commands-ui.h"
 129 #include "qapi/qmp/qdict.h"
 130 #include "block/qdict.h"
 131 #include "qapi/qmp/qerror.h"
 132 #include "sysemu/iothread.h"
 133 #include "qemu/guest-random.h"
 134 #include "qemu/keyval.h"
 135
 136 #include "config-host.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, 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     { NULL },
 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         Error *blocker = NULL;
1856         error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED, "smp");
1857         replay_add_blocker(blocker);
1858     }
1859 }
1860
1861 static void qemu_create_early_backends(void)
1862 {
1863     MachineClass *machine_class = MACHINE_GET_CLASS(current_machine);
1864 #if defined(CONFIG_SDL)
1865     const bool use_sdl = (dpy.type == DISPLAY_TYPE_SDL);
1866 #else
1867     const bool use_sdl = false;
1868 #endif
1869 #if defined(CONFIG_GTK)
1870     const bool use_gtk = (dpy.type == DISPLAY_TYPE_GTK);
1871 #else
1872     const bool use_gtk = false;
1873 #endif
1874
1875     if (dpy.has_window_close && !use_gtk && !use_sdl) {
1876         error_report("window-close is only valid for GTK and SDL, "
1877                      "ignoring option");
1878     }
1879
1880     qemu_display_early_init(&dpy);
1881     qemu_console_early_init();
1882
1883     if (dpy.has_gl && dpy.gl != DISPLAYGL_MODE_OFF && display_opengl == 0) {
1884 #if defined(CONFIG_OPENGL)
1885         error_report("OpenGL is not supported by the display");
1886 #else
1887         error_report("OpenGL support is disabled");
1888 #endif
1889         exit(1);
1890     }
1891
1892     object_option_foreach_add(object_create_early);
1893
1894     /* spice needs the timers to be initialized by this point */
1895     /* spice must initialize before audio as it changes the default audiodev */
1896     /* spice must initialize before chardevs (for spicevmc and spiceport) */
1897     qemu_spice.init();
1898
1899     qemu_opts_foreach(qemu_find_opts("chardev"),
1900                       chardev_init_func, NULL, &error_fatal);
1901
1902 #ifdef CONFIG_VIRTFS
1903     qemu_opts_foreach(qemu_find_opts("fsdev"),
1904                       fsdev_init_func, NULL, &error_fatal);
1905 #endif
1906
1907     /*
1908      * Note: we need to create audio and block backends before
1909      * setting machine properties, so they can be referred to.
1910      */
1911     configure_blockdev(&bdo_queue, machine_class, snapshot);
1912     if (!audio_init_audiodevs()) {
1913         exit(1);
1914     }
1915 }
1916
1917
1918 /*
1919  * The remainder of object creation happens after the
1920  * creation of chardev, fsdev, net clients and device data types.
1921  */
1922 static bool object_create_late(const char *type)
1923 {
1924     return !object_create_early(type) && !object_create_pre_sandbox(type);
1925 }
1926
1927 static void qemu_create_late_backends(void)
1928 {
1929     if (qtest_chrdev) {
1930         qtest_server_init(qtest_chrdev, qtest_log, &error_fatal);
1931     }
1932
1933     net_init_clients();
1934
1935     object_option_foreach_add(object_create_late);
1936
1937     if (tpm_init() < 0) {
1938         exit(1);
1939     }
1940
1941     qemu_opts_foreach(qemu_find_opts("mon"),
1942                       mon_init_func, NULL, &error_fatal);
1943
1944     if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
1945         exit(1);
1946     if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
1947         exit(1);
1948     if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
1949         exit(1);
1950
1951     /* now chardevs have been created we may have semihosting to connect */
1952     qemu_semihosting_chardev_init();
1953 }
1954
1955 static void qemu_resolve_machine_memdev(void)
1956 {
1957     if (ram_memdev_id) {
1958         Object *backend;
1959         ram_addr_t backend_size;
1960
1961         backend = object_resolve_path_type(ram_memdev_id,
1962                                            TYPE_MEMORY_BACKEND, NULL);
1963         if (!backend) {
1964             error_report("Memory backend '%s' not found", ram_memdev_id);
1965             exit(EXIT_FAILURE);
1966         }
1967         if (!have_custom_ram_size) {
1968             backend_size = object_property_get_uint(backend, "size",  &error_abort);
1969             current_machine->ram_size = backend_size;
1970         }
1971         object_property_set_link(OBJECT(current_machine),
1972                                  "memory-backend", backend, &error_fatal);
1973     }
1974 }
1975
1976 static void parse_memory_options(void)
1977 {
1978     QemuOpts *opts = qemu_find_opts_singleton("memory");
1979     QDict *dict, *prop;
1980     const char *mem_str;
1981     Location loc;
1982
1983     loc_push_none(&loc);
1984     qemu_opts_loc_restore(opts);
1985
1986     prop = qdict_new();
1987
1988     if (qemu_opt_get_size(opts, "size", 0) != 0) {
1989         /* Fix up legacy suffix-less format */
1990         mem_str = qemu_opt_get(opts, "size");
1991         if (g_ascii_isdigit(mem_str[strlen(mem_str) - 1])) {
1992             g_autofree char *mib_str = g_strdup_printf("%sM", mem_str);
1993             qdict_put_str(prop, "size", mib_str);
1994         } else {
1995             qdict_put_str(prop, "size", mem_str);
1996         }
1997     }
1998
1999     if (qemu_opt_get(opts, "maxmem")) {
2000         qdict_put_str(prop, "max-size", qemu_opt_get(opts, "maxmem"));
2001     }
2002     if (qemu_opt_get(opts, "slots")) {
2003         qdict_put_str(prop, "slots", qemu_opt_get(opts, "slots"));
2004     }
2005
2006     dict = qdict_new();
2007     qdict_put(dict, "memory", prop);
2008     keyval_merge(machine_opts_dict, dict, &error_fatal);
2009     qobject_unref(dict);
2010     loc_pop(&loc);
2011 }
2012
2013 static void qemu_create_machine(QDict *qdict)
2014 {
2015     MachineClass *machine_class = select_machine(qdict, &error_fatal);
2016     object_set_machine_compat_props(machine_class->compat_props);
2017
2018     current_machine = MACHINE(object_new_with_class(OBJECT_CLASS(machine_class)));
2019     object_property_add_child(object_get_root(), "machine",
2020                               OBJECT(current_machine));
2021     object_property_add_child(container_get(OBJECT(current_machine),
2022                                             "/unattached"),
2023                               "sysbus", OBJECT(sysbus_get_default()));
2024
2025     if (machine_class->minimum_page_bits) {
2026         if (!set_preferred_target_page_bits(machine_class->minimum_page_bits)) {
2027             /* This would be a board error: specifying a minimum smaller than
2028              * a target's compile-time fixed setting.
2029              */
2030             g_assert_not_reached();
2031         }
2032     }
2033
2034     cpu_exec_init_all();
2035     page_size_init();
2036
2037     if (machine_class->hw_version) {
2038         qemu_set_hw_version(machine_class->hw_version);
2039     }
2040
2041     /*
2042      * Get the default machine options from the machine if it is not already
2043      * specified either by the configuration file or by the command line.
2044      */
2045     if (machine_class->default_machine_opts) {
2046         QDict *default_opts =
2047             keyval_parse(machine_class->default_machine_opts, NULL, NULL,
2048                          &error_abort);
2049         qemu_apply_legacy_machine_options(default_opts);
2050         object_set_properties_from_keyval(OBJECT(current_machine), default_opts,
2051                                           false, &error_abort);
2052         qobject_unref(default_opts);
2053     }
2054 }
2055
2056 static int global_init_func(void *opaque, QemuOpts *opts, Error **errp)
2057 {
2058     GlobalProperty *g;
2059
2060     g = g_malloc0(sizeof(*g));
2061     g->driver   = qemu_opt_get(opts, "driver");
2062     g->property = qemu_opt_get(opts, "property");
2063     g->value    = qemu_opt_get(opts, "value");
2064     qdev_prop_register_global(g);
2065     return 0;
2066 }
2067
2068 /*
2069  * Return whether configuration group @group is stored in QemuOpts, or
2070  * recorded as one or more QDicts by qemu_record_config_group.
2071  */
2072 static bool is_qemuopts_group(const char *group)
2073 {
2074     if (g_str_equal(group, "object") ||
2075         g_str_equal(group, "machine") ||
2076         g_str_equal(group, "smp-opts") ||
2077         g_str_equal(group, "boot-opts")) {
2078         return false;
2079     }
2080     return true;
2081 }
2082
2083 static void qemu_record_config_group(const char *group, QDict *dict,
2084                                      bool from_json, Error **errp)
2085 {
2086     if (g_str_equal(group, "object")) {
2087         Visitor *v = qobject_input_visitor_new_keyval(QOBJECT(dict));
2088         object_option_add_visitor(v);
2089         visit_free(v);
2090     } else if (g_str_equal(group, "machine")) {
2091         /*
2092          * Cannot merge string-valued and type-safe dictionaries, so JSON
2093          * is not accepted yet for -M.
2094          */
2095         assert(!from_json);
2096         keyval_merge(machine_opts_dict, dict, errp);
2097     } else if (g_str_equal(group, "smp-opts")) {
2098         machine_merge_property("smp", dict, &error_fatal);
2099     } else if (g_str_equal(group, "boot-opts")) {
2100         machine_merge_property("boot", dict, &error_fatal);
2101     } else {
2102         abort();
2103     }
2104 }
2105
2106 /*
2107  * Parse non-QemuOpts config file groups, pass the rest to
2108  * qemu_config_do_parse.
2109  */
2110 static void qemu_parse_config_group(const char *group, QDict *qdict,
2111                                     void *opaque, Error **errp)
2112 {
2113     QObject *crumpled;
2114     if (is_qemuopts_group(group)) {
2115         qemu_config_do_parse(group, qdict, opaque, errp);
2116         return;
2117     }
2118
2119     crumpled = qdict_crumple(qdict, errp);
2120     if (!crumpled) {
2121         return;
2122     }
2123     switch (qobject_type(crumpled)) {
2124     case QTYPE_QDICT:
2125         qemu_record_config_group(group, qobject_to(QDict, crumpled), false, errp);
2126         break;
2127     case QTYPE_QLIST:
2128         error_setg(errp, "Lists cannot be at top level of a configuration section");
2129         break;
2130     default:
2131         g_assert_not_reached();
2132     }
2133     qobject_unref(crumpled);
2134 }
2135
2136 static void qemu_read_default_config_file(Error **errp)
2137 {
2138     ERRP_GUARD();
2139     int ret;
2140     g_autofree char *file = get_relocated_path(CONFIG_QEMU_CONFDIR "/qemu.conf");
2141
2142     ret = qemu_read_config_file(file, qemu_parse_config_group, errp);
2143     if (ret < 0) {
2144         if (ret == -ENOENT) {
2145             error_free(*errp);
2146             *errp = NULL;
2147         }
2148     }
2149 }
2150
2151 static void qemu_set_option(const char *str, Error **errp)
2152 {
2153     char group[64], id[64], arg[64];
2154     QemuOptsList *list;
2155     QemuOpts *opts;
2156     int rc, offset;
2157
2158     rc = sscanf(str, "%63[^.].%63[^.].%63[^=]%n", group, id, arg, &offset);
2159     if (rc < 3 || str[offset] != '=') {
2160         error_setg(errp, "can't parse: \"%s\"", str);
2161         return;
2162     }
2163
2164     if (!is_qemuopts_group(group)) {
2165         error_setg(errp, "-set is not supported with %s", group);
2166     } else {
2167         list = qemu_find_opts_err(group, errp);
2168         if (list) {
2169             opts = qemu_opts_find(list, id);
2170             if (!opts) {
2171                 error_setg(errp, "there is no %s \"%s\" defined", group, id);
2172                 return;
2173             }
2174             qemu_opt_set(opts, arg, str + offset + 1, errp);
2175         }
2176     }
2177 }
2178
2179 static void user_register_global_props(void)
2180 {
2181     qemu_opts_foreach(qemu_find_opts("global"),
2182                       global_init_func, NULL, NULL);
2183 }
2184
2185 static int do_configure_icount(void *opaque, QemuOpts *opts, Error **errp)
2186 {
2187     icount_configure(opts, errp);
2188     return 0;
2189 }
2190
2191 static int accelerator_set_property(void *opaque,
2192                                 const char *name, const char *value,
2193                                 Error **errp)
2194 {
2195     return object_parse_property_opt(opaque, name, value, "accel", errp);
2196 }
2197
2198 static int do_configure_accelerator(void *opaque, QemuOpts *opts, Error **errp)
2199 {
2200     bool *p_init_failed = opaque;
2201     const char *acc = qemu_opt_get(opts, "accel");
2202     AccelClass *ac = accel_find(acc);
2203     AccelState *accel;
2204     int ret;
2205     bool qtest_with_kvm;
2206
2207     qtest_with_kvm = g_str_equal(acc, "kvm") && qtest_chrdev != NULL;
2208
2209     if (!ac) {
2210         *p_init_failed = true;
2211         if (!qtest_with_kvm) {
2212             error_report("invalid accelerator %s", acc);
2213         }
2214         return 0;
2215     }
2216     accel = ACCEL(object_new_with_class(OBJECT_CLASS(ac)));
2217     object_apply_compat_props(OBJECT(accel));
2218     qemu_opt_foreach(opts, accelerator_set_property,
2219                      accel,
2220                      &error_fatal);
2221
2222     ret = accel_init_machine(accel, current_machine);
2223     if (ret < 0) {
2224         *p_init_failed = true;
2225         if (!qtest_with_kvm || ret != -ENOENT) {
2226             error_report("failed to initialize %s: %s", acc, strerror(-ret));
2227         }
2228         return 0;
2229     }
2230
2231     return 1;
2232 }
2233
2234 static void configure_accelerators(const char *progname)
2235 {
2236     bool init_failed = false;
2237
2238     qemu_opts_foreach(qemu_find_opts("icount"),
2239                       do_configure_icount, NULL, &error_fatal);
2240
2241     if (QTAILQ_EMPTY(&qemu_accel_opts.head)) {
2242         char **accel_list, **tmp;
2243
2244         if (accelerators == NULL) {
2245             /* Select the default accelerator */
2246             bool have_tcg = accel_find("tcg");
2247             bool have_kvm = accel_find("kvm");
2248
2249             if (have_tcg && have_kvm) {
2250                 if (g_str_has_suffix(progname, "kvm")) {
2251                     /* If the program name ends with "kvm", we prefer KVM */
2252                     accelerators = "kvm:tcg";
2253                 } else {
2254                     accelerators = "tcg:kvm";
2255                 }
2256             } else if (have_kvm) {
2257                 accelerators = "kvm";
2258             } else if (have_tcg) {
2259                 accelerators = "tcg";
2260             } else {
2261                 error_report("No accelerator selected and"
2262                              " no default accelerator available");
2263                 exit(1);
2264             }
2265         }
2266         accel_list = g_strsplit(accelerators, ":", 0);
2267
2268         for (tmp = accel_list; *tmp; tmp++) {
2269             /*
2270              * Filter invalid accelerators here, to prevent obscenities
2271              * such as "-machine accel=tcg,,thread=single".
2272              */
2273             if (accel_find(*tmp)) {
2274                 qemu_opts_parse_noisily(qemu_find_opts("accel"), *tmp, true);
2275             } else {
2276                 init_failed = true;
2277                 error_report("invalid accelerator %s", *tmp);
2278             }
2279         }
2280         g_strfreev(accel_list);
2281     } else {
2282         if (accelerators != NULL) {
2283             error_report("The -accel and \"-machine accel=\" options are incompatible");
2284             exit(1);
2285         }
2286     }
2287
2288     if (!qemu_opts_foreach(qemu_find_opts("accel"),
2289                            do_configure_accelerator, &init_failed, &error_fatal)) {
2290         if (!init_failed) {
2291             error_report("no accelerator found");
2292         }
2293         exit(1);
2294     }
2295
2296     if (init_failed && !qtest_chrdev) {
2297         error_report("falling back to %s", current_accel_name());
2298     }
2299
2300     if (icount_enabled() && !tcg_enabled()) {
2301         error_report("-icount is not allowed with hardware virtualization");
2302         exit(1);
2303     }
2304 }
2305
2306 static void qemu_validate_options(const QDict *machine_opts)
2307 {
2308     const char *kernel_filename = qdict_get_try_str(machine_opts, "kernel");
2309     const char *initrd_filename = qdict_get_try_str(machine_opts, "initrd");
2310     const char *kernel_cmdline = qdict_get_try_str(machine_opts, "append");
2311
2312     if (kernel_filename == NULL) {
2313          if (kernel_cmdline != NULL) {
2314               error_report("-append only allowed with -kernel option");
2315               exit(1);
2316           }
2317
2318           if (initrd_filename != NULL) {
2319               error_report("-initrd only allowed with -kernel option");
2320               exit(1);
2321           }
2322     }
2323
2324     if (loadvm && preconfig_requested) {
2325         error_report("'preconfig' and 'loadvm' options are "
2326                      "mutually exclusive");
2327         exit(EXIT_FAILURE);
2328     }
2329     if (incoming && preconfig_requested && strcmp(incoming, "defer") != 0) {
2330         error_report("'preconfig' supports '-incoming defer' only");
2331         exit(EXIT_FAILURE);
2332     }
2333
2334 #ifdef CONFIG_CURSES
2335     if (is_daemonized() && dpy.type == DISPLAY_TYPE_CURSES) {
2336         error_report("curses display cannot be used with -daemonize");
2337         exit(1);
2338     }
2339 #endif
2340 }
2341
2342 static void qemu_process_sugar_options(void)
2343 {
2344     if (mem_prealloc) {
2345         QObject *smp = qdict_get(machine_opts_dict, "smp");
2346         if (smp && qobject_type(smp) == QTYPE_QDICT) {
2347             QObject *cpus = qdict_get(qobject_to(QDict, smp), "cpus");
2348             if (cpus && qobject_type(cpus) == QTYPE_QSTRING) {
2349                 const char *val = qstring_get_str(qobject_to(QString, cpus));
2350                 object_register_sugar_prop("memory-backend", "prealloc-threads",
2351                                            val, false);
2352             }
2353         }
2354         object_register_sugar_prop("memory-backend", "prealloc", "on", false);
2355     }
2356 }
2357
2358 /* -action processing */
2359
2360 /*
2361  * Process all the -action parameters parsed from cmdline.
2362  */
2363 static int process_runstate_actions(void *opaque, QemuOpts *opts, Error **errp)
2364 {
2365     Error *local_err = NULL;
2366     QDict *qdict = qemu_opts_to_qdict(opts, NULL);
2367     QObject *ret = NULL;
2368     qmp_marshal_set_action(qdict, &ret, &local_err);
2369     qobject_unref(ret);
2370     qobject_unref(qdict);
2371     if (local_err) {
2372         error_propagate(errp, local_err);
2373         return 1;
2374     }
2375     return 0;
2376 }
2377
2378 static void qemu_process_early_options(void)
2379 {
2380     qemu_opts_foreach(qemu_find_opts("name"),
2381                       parse_name, NULL, &error_fatal);
2382
2383     object_option_foreach_add(object_create_pre_sandbox);
2384
2385 #ifdef CONFIG_SECCOMP
2386     QemuOptsList *olist = qemu_find_opts_err("sandbox", NULL);
2387     if (olist) {
2388         qemu_opts_foreach(olist, parse_sandbox, NULL, &error_fatal);
2389     }
2390 #endif
2391
2392     if (qemu_opts_foreach(qemu_find_opts("action"),
2393                           process_runstate_actions, NULL, &error_fatal)) {
2394         exit(1);
2395     }
2396
2397 #ifndef _WIN32
2398     qemu_opts_foreach(qemu_find_opts("add-fd"),
2399                       parse_add_fd, NULL, &error_fatal);
2400
2401     qemu_opts_foreach(qemu_find_opts("add-fd"),
2402                       cleanup_add_fd, NULL, &error_fatal);
2403 #endif
2404
2405     /* Open the logfile at this point and set the log mask if necessary.  */
2406     {
2407         int mask = 0;
2408         if (log_mask) {
2409             mask = qemu_str_to_log_mask(log_mask);
2410             if (!mask) {
2411                 qemu_print_log_usage(stdout);
2412                 exit(1);
2413             }
2414         }
2415         qemu_set_log_filename_flags(log_file, mask, &error_fatal);
2416     }
2417
2418     qemu_add_default_firmwarepath();
2419 }
2420
2421 static void qemu_process_help_options(void)
2422 {
2423     /*
2424      * Check for -cpu help and -device help before we call select_machine(),
2425      * which will return an error if the architecture has no default machine
2426      * type and the user did not specify one, so that the user doesn't need
2427      * to say '-cpu help -machine something'.
2428      */
2429     if (cpu_option && is_help_option(cpu_option)) {
2430         list_cpus(cpu_option);
2431         exit(0);
2432     }
2433
2434     if (qemu_opts_foreach(qemu_find_opts("device"),
2435                           device_help_func, NULL, NULL)) {
2436         exit(0);
2437     }
2438
2439     /* -L help lists the data directories and exits. */
2440     if (list_data_dirs) {
2441         qemu_list_data_dirs();
2442         exit(0);
2443     }
2444 }
2445
2446 static void qemu_maybe_daemonize(const char *pid_file)
2447 {
2448     Error *err = NULL;
2449
2450     os_daemonize();
2451     rcu_disable_atfork();
2452
2453     if (pid_file) {
2454         char *pid_file_realpath = NULL;
2455
2456         if (!qemu_write_pidfile(pid_file, &err)) {
2457             error_reportf_err(err, "cannot create PID file: ");
2458             exit(1);
2459         }
2460
2461         pid_file_realpath = g_malloc0(PATH_MAX);
2462         if (!realpath(pid_file, pid_file_realpath)) {
2463             error_report("cannot resolve PID file path: %s: %s",
2464                          pid_file, strerror(errno));
2465             unlink(pid_file);
2466             exit(1);
2467         }
2468
2469         qemu_unlink_pidfile_notifier = (struct UnlinkPidfileNotifier) {
2470             .notifier = {
2471                 .notify = qemu_unlink_pidfile,
2472             },
2473             .pid_file_realpath = pid_file_realpath,
2474         };
2475         qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier.notifier);
2476     }
2477 }
2478
2479 static void qemu_init_displays(void)
2480 {
2481     DisplayState *ds;
2482
2483     /* init local displays */
2484     ds = init_displaystate();
2485     qemu_display_init(ds, &dpy);
2486
2487     /* must be after terminal init, SDL library changes signal handlers */
2488     os_setup_signal_handling();
2489
2490     /* init remote displays */
2491 #ifdef CONFIG_VNC
2492     qemu_opts_foreach(qemu_find_opts("vnc"),
2493                       vnc_init_func, NULL, &error_fatal);
2494 #endif
2495
2496     if (using_spice) {
2497         qemu_spice.display_init();
2498     }
2499 }
2500
2501 static void qemu_init_board(void)
2502 {
2503     /* process plugin before CPUs are created, but once -smp has been parsed */
2504     qemu_plugin_load_list(&plugin_list, &error_fatal);
2505
2506     /* From here on we enter MACHINE_PHASE_INITIALIZED.  */
2507     machine_run_board_init(current_machine, mem_path, &error_fatal);
2508
2509     drive_check_orphaned();
2510
2511     realtime_init();
2512
2513     if (hax_enabled()) {
2514         /* FIXME: why isn't cpu_synchronize_all_post_init enough? */
2515         hax_sync_vcpus();
2516     }
2517 }
2518
2519 static void qemu_create_cli_devices(void)
2520 {
2521     DeviceOption *opt;
2522
2523     soundhw_init();
2524
2525     qemu_opts_foreach(qemu_find_opts("fw_cfg"),
2526                       parse_fw_cfg, fw_cfg_find(), &error_fatal);
2527
2528     /* init USB devices */
2529     if (machine_usb(current_machine)) {
2530         if (foreach_device_config(DEV_USB, usb_parse) < 0)
2531             exit(1);
2532     }
2533
2534     /* init generic devices */
2535     rom_set_order_override(FW_CFG_ORDER_OVERRIDE_DEVICE);
2536     qemu_opts_foreach(qemu_find_opts("device"),
2537                       device_init_func, NULL, &error_fatal);
2538     QTAILQ_FOREACH(opt, &device_opts, next) {
2539         DeviceState *dev;
2540         loc_push_restore(&opt->loc);
2541         /*
2542          * TODO Eventually we should call qmp_device_add() here to make sure it
2543          * behaves the same, but QMP still has to accept incorrectly typed
2544          * options until libvirt is fixed and we want to be strict on the CLI
2545          * from the start, so call qdev_device_add_from_qdict() directly for
2546          * now.
2547          */
2548         dev = qdev_device_add_from_qdict(opt->opts, true, &error_fatal);
2549         object_unref(OBJECT(dev));
2550         loc_pop(&opt->loc);
2551     }
2552     rom_reset_order_override();
2553 }
2554
2555 static void qemu_machine_creation_done(void)
2556 {
2557     MachineState *machine = MACHINE(qdev_get_machine());
2558
2559     /* Did we create any drives that we failed to create a device for? */
2560     drive_check_orphaned();
2561
2562     /* Don't warn about the default network setup that you get if
2563      * no command line -net or -netdev options are specified. There
2564      * are two cases that we would otherwise complain about:
2565      * (1) board doesn't support a NIC but the implicit "-net nic"
2566      * requested one
2567      * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
2568      * sets up a nic that isn't connected to anything.
2569      */
2570     if (!default_net && (!qtest_enabled() || has_defaults)) {
2571         net_check_clients();
2572     }
2573
2574     qdev_prop_check_globals();
2575
2576     qdev_machine_creation_done();
2577
2578     if (machine->cgs) {
2579         /*
2580          * Verify that Confidential Guest Support has actually been initialized
2581          */
2582         assert(machine->cgs->ready);
2583     }
2584
2585     if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) {
2586         exit(1);
2587     }
2588     if (!vga_interface_created && !default_vga &&
2589         vga_interface_type != VGA_NONE) {
2590         warn_report("A -vga option was passed but this machine "
2591                     "type does not use that option; "
2592                     "No VGA device has been created");
2593     }
2594 }
2595
2596 void qmp_x_exit_preconfig(Error **errp)
2597 {
2598     if (phase_check(PHASE_MACHINE_INITIALIZED)) {
2599         error_setg(errp, "The command is permitted only before machine initialization");
2600         return;
2601     }
2602
2603     qemu_init_board();
2604     qemu_create_cli_devices();
2605     qemu_machine_creation_done();
2606
2607     if (loadvm) {
2608         load_snapshot(loadvm, NULL, false, NULL, &error_fatal);
2609     }
2610     if (replay_mode != REPLAY_MODE_NONE) {
2611         replay_vmstate_init();
2612     }
2613
2614     if (incoming) {
2615         Error *local_err = NULL;
2616         if (strcmp(incoming, "defer") != 0) {
2617             qmp_migrate_incoming(incoming, &local_err);
2618             if (local_err) {
2619                 error_reportf_err(local_err, "-incoming %s: ", incoming);
2620                 exit(1);
2621             }
2622         }
2623     } else if (autostart) {
2624         qmp_cont(NULL);
2625     }
2626 }
2627
2628 void qemu_init(int argc, char **argv)
2629 {
2630     QemuOpts *opts;
2631     QemuOpts *icount_opts = NULL, *accel_opts = NULL;
2632     QemuOptsList *olist;
2633     int optind;
2634     const char *optarg;
2635     MachineClass *machine_class;
2636     bool userconfig = true;
2637     FILE *vmstate_dump_file = NULL;
2638
2639     qemu_add_opts(&qemu_drive_opts);
2640     qemu_add_drive_opts(&qemu_legacy_drive_opts);
2641     qemu_add_drive_opts(&qemu_common_drive_opts);
2642     qemu_add_drive_opts(&qemu_drive_opts);
2643     qemu_add_drive_opts(&bdrv_runtime_opts);
2644     qemu_add_opts(&qemu_chardev_opts);
2645     qemu_add_opts(&qemu_device_opts);
2646     qemu_add_opts(&qemu_netdev_opts);
2647     qemu_add_opts(&qemu_nic_opts);
2648     qemu_add_opts(&qemu_net_opts);
2649     qemu_add_opts(&qemu_rtc_opts);
2650     qemu_add_opts(&qemu_global_opts);
2651     qemu_add_opts(&qemu_mon_opts);
2652     qemu_add_opts(&qemu_trace_opts);
2653     qemu_plugin_add_opts();
2654     qemu_add_opts(&qemu_option_rom_opts);
2655     qemu_add_opts(&qemu_accel_opts);
2656     qemu_add_opts(&qemu_mem_opts);
2657     qemu_add_opts(&qemu_smp_opts);
2658     qemu_add_opts(&qemu_boot_opts);
2659     qemu_add_opts(&qemu_add_fd_opts);
2660     qemu_add_opts(&qemu_object_opts);
2661     qemu_add_opts(&qemu_tpmdev_opts);
2662     qemu_add_opts(&qemu_overcommit_opts);
2663     qemu_add_opts(&qemu_msg_opts);
2664     qemu_add_opts(&qemu_name_opts);
2665     qemu_add_opts(&qemu_numa_opts);
2666     qemu_add_opts(&qemu_icount_opts);
2667     qemu_add_opts(&qemu_semihosting_config_opts);
2668     qemu_add_opts(&qemu_fw_cfg_opts);
2669     qemu_add_opts(&qemu_action_opts);
2670     module_call_init(MODULE_INIT_OPTS);
2671
2672     error_init(argv[0]);
2673     qemu_init_exec_dir(argv[0]);
2674
2675     qemu_init_arch_modules();
2676
2677     qemu_init_subsystems();
2678
2679     /* first pass of option parsing */
2680     optind = 1;
2681     while (optind < argc) {
2682         if (argv[optind][0] != '-') {
2683             /* disk image */
2684             optind++;
2685         } else {
2686             const QEMUOption *popt;
2687
2688             popt = lookup_opt(argc, argv, &optarg, &optind);
2689             switch (popt->index) {
2690             case QEMU_OPTION_nouserconfig:
2691                 userconfig = false;
2692                 break;
2693             }
2694         }
2695     }
2696
2697     machine_opts_dict = qdict_new();
2698     if (userconfig) {
2699         qemu_read_default_config_file(&error_fatal);
2700     }
2701
2702     /* second pass of option parsing */
2703     optind = 1;
2704     for(;;) {
2705         if (optind >= argc)
2706             break;
2707         if (argv[optind][0] != '-') {
2708             loc_set_cmdline(argv, optind, 1);
2709             drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
2710         } else {
2711             const QEMUOption *popt;
2712
2713             popt = lookup_opt(argc, argv, &optarg, &optind);
2714             if (!(popt->arch_mask & arch_type)) {
2715                 error_report("Option not supported for this target");
2716                 exit(1);
2717             }
2718             switch(popt->index) {
2719             case QEMU_OPTION_cpu:
2720                 /* hw initialization will check this */
2721                 cpu_option = optarg;
2722                 break;
2723             case QEMU_OPTION_hda:
2724             case QEMU_OPTION_hdb:
2725             case QEMU_OPTION_hdc:
2726             case QEMU_OPTION_hdd:
2727                 drive_add(IF_DEFAULT, popt->index - QEMU_OPTION_hda, optarg,
2728                           HD_OPTS);
2729                 break;
2730             case QEMU_OPTION_blockdev:
2731                 {
2732                     Visitor *v;
2733                     BlockdevOptionsQueueEntry *bdo;
2734
2735                     v = qobject_input_visitor_new_str(optarg, "driver",
2736                                                       &error_fatal);
2737
2738                     bdo = g_new(BlockdevOptionsQueueEntry, 1);
2739                     visit_type_BlockdevOptions(v, NULL, &bdo->bdo,
2740                                                &error_fatal);
2741                     visit_free(v);
2742                     loc_save(&bdo->loc);
2743                     QSIMPLEQ_INSERT_TAIL(&bdo_queue, bdo, entry);
2744                     break;
2745                 }
2746             case QEMU_OPTION_drive:
2747                 opts = qemu_opts_parse_noisily(qemu_find_opts("drive"),
2748                                                optarg, false);
2749                 if (opts == NULL) {
2750                     exit(1);
2751                 }
2752                 break;
2753             case QEMU_OPTION_set:
2754                 qemu_set_option(optarg, &error_fatal);
2755                 break;
2756             case QEMU_OPTION_global:
2757                 if (qemu_global_option(optarg) != 0)
2758                     exit(1);
2759                 break;
2760             case QEMU_OPTION_mtdblock:
2761                 drive_add(IF_MTD, -1, optarg, MTD_OPTS);
2762                 break;
2763             case QEMU_OPTION_sd:
2764                 drive_add(IF_SD, -1, optarg, SD_OPTS);
2765                 break;
2766             case QEMU_OPTION_pflash:
2767                 drive_add(IF_PFLASH, -1, optarg, PFLASH_OPTS);
2768                 break;
2769             case QEMU_OPTION_snapshot:
2770                 {
2771                     Error *blocker = NULL;
2772                     snapshot = 1;
2773                     error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED,
2774                                "-snapshot");
2775                     replay_add_blocker(blocker);
2776                 }
2777                 break;
2778             case QEMU_OPTION_numa:
2779                 opts = qemu_opts_parse_noisily(qemu_find_opts("numa"),
2780                                                optarg, true);
2781                 if (!opts) {
2782                     exit(1);
2783                 }
2784                 break;
2785             case QEMU_OPTION_display:
2786                 parse_display(optarg);
2787                 break;
2788             case QEMU_OPTION_nographic:
2789                 qdict_put_str(machine_opts_dict, "graphics", "off");
2790                 nographic = true;
2791                 dpy.type = DISPLAY_TYPE_NONE;
2792                 break;
2793             case QEMU_OPTION_portrait:
2794                 graphic_rotate = 90;
2795                 break;
2796             case QEMU_OPTION_rotate:
2797                 graphic_rotate = strtol(optarg, (char **) &optarg, 10);
2798                 if (graphic_rotate != 0 && graphic_rotate != 90 &&
2799                     graphic_rotate != 180 && graphic_rotate != 270) {
2800                     error_report("only 90, 180, 270 deg rotation is available");
2801                     exit(1);
2802                 }
2803                 break;
2804             case QEMU_OPTION_kernel:
2805                 qdict_put_str(machine_opts_dict, "kernel", optarg);
2806                 break;
2807             case QEMU_OPTION_initrd:
2808                 qdict_put_str(machine_opts_dict, "initrd", optarg);
2809                 break;
2810             case QEMU_OPTION_append:
2811                 qdict_put_str(machine_opts_dict, "append", optarg);
2812                 break;
2813             case QEMU_OPTION_dtb:
2814                 qdict_put_str(machine_opts_dict, "dtb", optarg);
2815                 break;
2816             case QEMU_OPTION_cdrom:
2817                 drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS);
2818                 break;
2819             case QEMU_OPTION_boot:
2820                 machine_parse_property_opt(qemu_find_opts("boot-opts"), "boot", optarg);
2821                 break;
2822             case QEMU_OPTION_fda:
2823             case QEMU_OPTION_fdb:
2824                 drive_add(IF_FLOPPY, popt->index - QEMU_OPTION_fda,
2825                           optarg, FD_OPTS);
2826                 break;
2827             case QEMU_OPTION_no_fd_bootchk:
2828                 fd_bootchk = 0;
2829                 break;
2830             case QEMU_OPTION_netdev:
2831                 default_net = 0;
2832                 if (netdev_is_modern(optarg)) {
2833                     netdev_parse_modern(optarg);
2834                 } else {
2835                     net_client_parse(qemu_find_opts("netdev"), optarg);
2836                 }
2837                 break;
2838             case QEMU_OPTION_nic:
2839                 default_net = 0;
2840                 net_client_parse(qemu_find_opts("nic"), optarg);
2841                 break;
2842             case QEMU_OPTION_net:
2843                 default_net = 0;
2844                 net_client_parse(qemu_find_opts("net"), optarg);
2845                 break;
2846 #ifdef CONFIG_LIBISCSI
2847             case QEMU_OPTION_iscsi:
2848                 opts = qemu_opts_parse_noisily(qemu_find_opts("iscsi"),
2849                                                optarg, false);
2850                 if (!opts) {
2851                     exit(1);
2852                 }
2853                 break;
2854 #endif
2855             case QEMU_OPTION_audio_help:
2856                 audio_legacy_help();
2857                 exit (0);
2858                 break;
2859             case QEMU_OPTION_audiodev:
2860                 audio_parse_option(optarg);
2861                 break;
2862             case QEMU_OPTION_audio: {
2863                 bool help;
2864                 char *model;
2865                 Audiodev *dev = NULL;
2866                 Visitor *v;
2867                 QDict *dict = keyval_parse(optarg, "driver", &help, &error_fatal);
2868                 if (help || (qdict_haskey(dict, "driver") &&
2869                              is_help_option(qdict_get_str(dict, "driver")))) {
2870                     audio_help();
2871                     exit(EXIT_SUCCESS);
2872                 }
2873                 if (!qdict_haskey(dict, "id")) {
2874                     qdict_put_str(dict, "id", "audiodev0");
2875                 }
2876                 if (!qdict_haskey(dict, "model")) {
2877                     error_setg(&error_fatal, "Parameter 'model' is missing");
2878                 }
2879                 model = g_strdup(qdict_get_str(dict, "model"));
2880                 qdict_del(dict, "model");
2881                 if (is_help_option(model)) {
2882                     show_valid_soundhw();
2883                     exit(0);
2884                 }
2885                 v = qobject_input_visitor_new_keyval(QOBJECT(dict));
2886                 qobject_unref(dict);
2887                 visit_type_Audiodev(v, NULL, &dev, &error_fatal);
2888                 visit_free(v);
2889                 audio_define(dev);
2890                 select_soundhw(model, dev->id);
2891                 g_free(model);
2892                 break;
2893             }
2894             case QEMU_OPTION_h:
2895                 help(0);
2896                 break;
2897             case QEMU_OPTION_version:
2898                 version();
2899                 exit(0);
2900                 break;
2901             case QEMU_OPTION_m:
2902                 opts = qemu_opts_parse_noisily(qemu_find_opts("memory"), optarg, true);
2903                 if (opts == NULL) {
2904                     exit(1);
2905                 }
2906                 break;
2907 #ifdef CONFIG_TPM
2908             case QEMU_OPTION_tpmdev:
2909                 if (tpm_config_parse(qemu_find_opts("tpmdev"), optarg) < 0) {
2910                     exit(1);
2911                 }
2912                 break;
2913 #endif
2914             case QEMU_OPTION_mempath:
2915                 mem_path = optarg;
2916                 break;
2917             case QEMU_OPTION_mem_prealloc:
2918                 mem_prealloc = 1;
2919                 break;
2920             case QEMU_OPTION_d:
2921                 log_mask = optarg;
2922                 break;
2923             case QEMU_OPTION_D:
2924                 log_file = optarg;
2925                 break;
2926             case QEMU_OPTION_DFILTER:
2927                 qemu_set_dfilter_ranges(optarg, &error_fatal);
2928                 break;
2929             case QEMU_OPTION_seed:
2930                 qemu_guest_random_seed_main(optarg, &error_fatal);
2931                 break;
2932             case QEMU_OPTION_s:
2933                 add_device_config(DEV_GDB, "tcp::" DEFAULT_GDBSTUB_PORT);
2934                 break;
2935             case QEMU_OPTION_gdb:
2936                 add_device_config(DEV_GDB, optarg);
2937                 break;
2938             case QEMU_OPTION_L:
2939                 if (is_help_option(optarg)) {
2940                     list_data_dirs = true;
2941                 } else {
2942                     qemu_add_data_dir(g_strdup(optarg));
2943                 }
2944                 break;
2945             case QEMU_OPTION_bios:
2946                 qdict_put_str(machine_opts_dict, "firmware", optarg);
2947                 break;
2948             case QEMU_OPTION_singlestep:
2949                 singlestep = 1;
2950                 break;
2951             case QEMU_OPTION_S:
2952                 autostart = 0;
2953                 break;
2954             case QEMU_OPTION_k:
2955                 keyboard_layout = optarg;
2956                 break;
2957             case QEMU_OPTION_vga:
2958                 vga_model = optarg;
2959                 default_vga = 0;
2960                 break;
2961             case QEMU_OPTION_g:
2962                 {
2963                     const char *p;
2964                     int w, h, depth;
2965                     p = optarg;
2966                     w = strtol(p, (char **)&p, 10);
2967                     if (w <= 0) {
2968                     graphic_error:
2969                         error_report("invalid resolution or depth");
2970                         exit(1);
2971                     }
2972                     if (*p != 'x')
2973                         goto graphic_error;
2974                     p++;
2975                     h = strtol(p, (char **)&p, 10);
2976                     if (h <= 0)
2977                         goto graphic_error;
2978                     if (*p == 'x') {
2979                         p++;
2980                         depth = strtol(p, (char **)&p, 10);
2981                         if (depth != 1 && depth != 2 && depth != 4 &&
2982                             depth != 8 && depth != 15 && depth != 16 &&
2983                             depth != 24 && depth != 32)
2984                             goto graphic_error;
2985                     } else if (*p == '\0') {
2986                         depth = graphic_depth;
2987                     } else {
2988                         goto graphic_error;
2989                     }
2990
2991                     graphic_width = w;
2992                     graphic_height = h;
2993                     graphic_depth = depth;
2994                 }
2995                 break;
2996             case QEMU_OPTION_echr:
2997                 {
2998                     char *r;
2999                     term_escape_char = strtol(optarg, &r, 0);
3000                     if (r == optarg)
3001                         printf("Bad argument to echr\n");
3002                     break;
3003                 }
3004             case QEMU_OPTION_monitor:
3005                 default_monitor = 0;
3006                 if (strncmp(optarg, "none", 4)) {
3007                     monitor_parse(optarg, "readline", false);
3008                 }
3009                 break;
3010             case QEMU_OPTION_qmp:
3011                 monitor_parse(optarg, "control", false);
3012                 default_monitor = 0;
3013                 break;
3014             case QEMU_OPTION_qmp_pretty:
3015                 monitor_parse(optarg, "control", true);
3016                 default_monitor = 0;
3017                 break;
3018             case QEMU_OPTION_mon:
3019                 opts = qemu_opts_parse_noisily(qemu_find_opts("mon"), optarg,
3020                                                true);
3021                 if (!opts) {
3022                     exit(1);
3023                 }
3024                 default_monitor = 0;
3025                 break;
3026             case QEMU_OPTION_chardev:
3027                 opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
3028                                                optarg, true);
3029                 if (!opts) {
3030                     exit(1);
3031                 }
3032                 break;
3033             case QEMU_OPTION_fsdev:
3034                 olist = qemu_find_opts("fsdev");
3035                 if (!olist) {
3036                     error_report("fsdev support is disabled");
3037                     exit(1);
3038                 }
3039                 opts = qemu_opts_parse_noisily(olist, optarg, true);
3040                 if (!opts) {
3041                     exit(1);
3042                 }
3043                 break;
3044             case QEMU_OPTION_virtfs: {
3045                 QemuOpts *fsdev;
3046                 QemuOpts *device;
3047                 const char *writeout, *sock_fd, *socket, *path, *security_model,
3048                            *multidevs;
3049
3050                 olist = qemu_find_opts("virtfs");
3051                 if (!olist) {
3052                     error_report("virtfs support is disabled");
3053                     exit(1);
3054                 }
3055                 opts = qemu_opts_parse_noisily(olist, optarg, true);
3056                 if (!opts) {
3057                     exit(1);
3058                 }
3059
3060                 if (qemu_opt_get(opts, "fsdriver") == NULL ||
3061                     qemu_opt_get(opts, "mount_tag") == NULL) {
3062                     error_report("Usage: -virtfs fsdriver,mount_tag=tag");
3063                     exit(1);
3064                 }
3065                 fsdev = qemu_opts_create(qemu_find_opts("fsdev"),
3066                                          qemu_opts_id(opts) ?:
3067                                          qemu_opt_get(opts, "mount_tag"),
3068                                          1, NULL);
3069                 if (!fsdev) {
3070                     error_report("duplicate or invalid fsdev id: %s",
3071                                  qemu_opt_get(opts, "mount_tag"));
3072                     exit(1);
3073                 }
3074
3075                 writeout = qemu_opt_get(opts, "writeout");
3076                 if (writeout) {
3077 #ifdef CONFIG_SYNC_FILE_RANGE
3078                     qemu_opt_set(fsdev, "writeout", writeout, &error_abort);
3079 #else
3080                     error_report("writeout=immediate not supported "
3081                                  "on this platform");
3082                     exit(1);
3083 #endif
3084                 }
3085                 qemu_opt_set(fsdev, "fsdriver",
3086                              qemu_opt_get(opts, "fsdriver"), &error_abort);
3087                 path = qemu_opt_get(opts, "path");
3088                 if (path) {
3089                     qemu_opt_set(fsdev, "path", path, &error_abort);
3090                 }
3091                 security_model = qemu_opt_get(opts, "security_model");
3092                 if (security_model) {
3093                     qemu_opt_set(fsdev, "security_model", security_model,
3094                                  &error_abort);
3095                 }
3096                 socket = qemu_opt_get(opts, "socket");
3097                 if (socket) {
3098                     qemu_opt_set(fsdev, "socket", socket, &error_abort);
3099                 }
3100                 sock_fd = qemu_opt_get(opts, "sock_fd");
3101                 if (sock_fd) {
3102                     qemu_opt_set(fsdev, "sock_fd", sock_fd, &error_abort);
3103                 }
3104
3105                 qemu_opt_set_bool(fsdev, "readonly",
3106                                   qemu_opt_get_bool(opts, "readonly", 0),
3107                                   &error_abort);
3108                 multidevs = qemu_opt_get(opts, "multidevs");
3109                 if (multidevs) {
3110                     qemu_opt_set(fsdev, "multidevs", multidevs, &error_abort);
3111                 }
3112                 device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
3113                                           &error_abort);
3114                 qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
3115                 qemu_opt_set(device, "fsdev",
3116                              qemu_opts_id(fsdev), &error_abort);
3117                 qemu_opt_set(device, "mount_tag",
3118                              qemu_opt_get(opts, "mount_tag"), &error_abort);
3119                 break;
3120             }
3121             case QEMU_OPTION_serial:
3122                 add_device_config(DEV_SERIAL, optarg);
3123                 default_serial = 0;
3124                 if (strncmp(optarg, "mon:", 4) == 0) {
3125                     default_monitor = 0;
3126                 }
3127                 break;
3128             case QEMU_OPTION_action:
3129                 olist = qemu_find_opts("action");
3130                 if (!qemu_opts_parse_noisily(olist, optarg, false)) {
3131                      exit(1);
3132                 }
3133                 break;
3134             case QEMU_OPTION_watchdog_action: {
3135                 QemuOpts *opts;
3136                 opts = qemu_opts_create(qemu_find_opts("action"), NULL, 0, &error_abort);
3137                 qemu_opt_set(opts, "watchdog", optarg, &error_abort);
3138                 break;
3139             }
3140             case QEMU_OPTION_parallel:
3141                 add_device_config(DEV_PARALLEL, optarg);
3142                 default_parallel = 0;
3143                 if (strncmp(optarg, "mon:", 4) == 0) {
3144                     default_monitor = 0;
3145                 }
3146                 break;
3147             case QEMU_OPTION_debugcon:
3148                 add_device_config(DEV_DEBUGCON, optarg);
3149                 break;
3150             case QEMU_OPTION_loadvm:
3151                 loadvm = optarg;
3152                 break;
3153             case QEMU_OPTION_full_screen:
3154                 dpy.has_full_screen = true;
3155                 dpy.full_screen = true;
3156                 break;
3157             case QEMU_OPTION_pidfile:
3158                 pid_file = optarg;
3159                 break;
3160             case QEMU_OPTION_win2k_hack:
3161                 win2k_install_hack = 1;
3162                 break;
3163             case QEMU_OPTION_acpitable:
3164                 opts = qemu_opts_parse_noisily(qemu_find_opts("acpi"),
3165                                                optarg, true);
3166                 if (!opts) {
3167                     exit(1);
3168                 }
3169                 acpi_table_add(opts, &error_fatal);
3170                 break;
3171             case QEMU_OPTION_smbios:
3172                 opts = qemu_opts_parse_noisily(qemu_find_opts("smbios"),
3173                                                optarg, false);
3174                 if (!opts) {
3175                     exit(1);
3176                 }
3177                 smbios_entry_add(opts, &error_fatal);
3178                 break;
3179             case QEMU_OPTION_fwcfg:
3180                 opts = qemu_opts_parse_noisily(qemu_find_opts("fw_cfg"),
3181                                                optarg, true);
3182                 if (opts == NULL) {
3183                     exit(1);
3184                 }
3185                 break;
3186             case QEMU_OPTION_preconfig:
3187                 preconfig_requested = true;
3188                 break;
3189             case QEMU_OPTION_enable_kvm:
3190                 qdict_put_str(machine_opts_dict, "accel", "kvm");
3191                 break;
3192             case QEMU_OPTION_M:
3193             case QEMU_OPTION_machine:
3194                 {
3195                     bool help;
3196
3197                     keyval_parse_into(machine_opts_dict, optarg, "type", &help, &error_fatal);
3198                     if (help) {
3199                         machine_help_func(machine_opts_dict);
3200                         exit(EXIT_SUCCESS);
3201                     }
3202                     break;
3203                 }
3204             case QEMU_OPTION_accel:
3205                 accel_opts = qemu_opts_parse_noisily(qemu_find_opts("accel"),
3206                                                      optarg, true);
3207                 optarg = qemu_opt_get(accel_opts, "accel");
3208                 if (!optarg || is_help_option(optarg)) {
3209                     printf("Accelerators supported in QEMU binary:\n");
3210                     GSList *el, *accel_list = object_class_get_list(TYPE_ACCEL,
3211                                                                     false);
3212                     for (el = accel_list; el; el = el->next) {
3213                         gchar *typename = g_strdup(object_class_get_name(
3214                                                    OBJECT_CLASS(el->data)));
3215                         /* omit qtest which is used for tests only */
3216                         if (g_strcmp0(typename, ACCEL_CLASS_NAME("qtest")) &&
3217                             g_str_has_suffix(typename, ACCEL_CLASS_SUFFIX)) {
3218                             gchar **optname = g_strsplit(typename,
3219                                                          ACCEL_CLASS_SUFFIX, 0);
3220                             printf("%s\n", optname[0]);
3221                             g_strfreev(optname);
3222                         }
3223                         g_free(typename);
3224                     }
3225                     g_slist_free(accel_list);
3226                     exit(0);
3227                 }
3228                 break;
3229             case QEMU_OPTION_usb:
3230                 qdict_put_str(machine_opts_dict, "usb", "on");
3231                 break;
3232             case QEMU_OPTION_usbdevice:
3233                 qdict_put_str(machine_opts_dict, "usb", "on");
3234                 add_device_config(DEV_USB, optarg);
3235                 break;
3236             case QEMU_OPTION_device:
3237                 if (optarg[0] == '{') {
3238                     QObject *obj = qobject_from_json(optarg, &error_fatal);
3239                     DeviceOption *opt = g_new0(DeviceOption, 1);
3240                     opt->opts = qobject_to(QDict, obj);
3241                     loc_save(&opt->loc);
3242                     assert(opt->opts != NULL);
3243                     QTAILQ_INSERT_TAIL(&device_opts, opt, next);
3244                 } else {
3245                     if (!qemu_opts_parse_noisily(qemu_find_opts("device"),
3246                                                  optarg, true)) {
3247                         exit(1);
3248                     }
3249                 }
3250                 break;
3251             case QEMU_OPTION_smp:
3252                 machine_parse_property_opt(qemu_find_opts("smp-opts"),
3253                                            "smp", optarg);
3254                 break;
3255             case QEMU_OPTION_vnc:
3256                 vnc_parse(optarg);
3257                 break;
3258             case QEMU_OPTION_no_acpi:
3259                 qdict_put_str(machine_opts_dict, "acpi", "off");
3260                 break;
3261             case QEMU_OPTION_no_hpet:
3262                 qdict_put_str(machine_opts_dict, "hpet", "off");
3263                 break;
3264             case QEMU_OPTION_no_reboot:
3265                 olist = qemu_find_opts("action");
3266                 qemu_opts_parse_noisily(olist, "reboot=shutdown", false);
3267                 break;
3268             case QEMU_OPTION_no_shutdown:
3269                 olist = qemu_find_opts("action");
3270                 qemu_opts_parse_noisily(olist, "shutdown=pause", false);
3271                 break;
3272             case QEMU_OPTION_uuid:
3273                 if (qemu_uuid_parse(optarg, &qemu_uuid) < 0) {
3274                     error_report("failed to parse UUID string: wrong format");
3275                     exit(1);
3276                 }
3277                 qemu_uuid_set = true;
3278                 break;
3279             case QEMU_OPTION_option_rom:
3280                 if (nb_option_roms >= MAX_OPTION_ROMS) {
3281                     error_report("too many option ROMs");
3282                     exit(1);
3283                 }
3284                 opts = qemu_opts_parse_noisily(qemu_find_opts("option-rom"),
3285                                                optarg, true);
3286                 if (!opts) {
3287                     exit(1);
3288                 }
3289                 option_rom[nb_option_roms].name = qemu_opt_get(opts, "romfile");
3290                 option_rom[nb_option_roms].bootindex =
3291                     qemu_opt_get_number(opts, "bootindex", -1);
3292                 if (!option_rom[nb_option_roms].name) {
3293                     error_report("Option ROM file is not specified");
3294                     exit(1);
3295                 }
3296                 nb_option_roms++;
3297                 break;
3298             case QEMU_OPTION_semihosting:
3299                 qemu_semihosting_enable();
3300                 break;
3301             case QEMU_OPTION_semihosting_config:
3302                 if (qemu_semihosting_config_options(optarg) != 0) {
3303                     exit(1);
3304                 }
3305                 break;
3306             case QEMU_OPTION_name:
3307                 opts = qemu_opts_parse_noisily(qemu_find_opts("name"),
3308                                                optarg, true);
3309                 if (!opts) {
3310                     exit(1);
3311                 }
3312                 /* Capture guest name if -msg guest-name is used later */
3313                 error_guest_name = qemu_opt_get(opts, "guest");
3314                 break;
3315             case QEMU_OPTION_prom_env:
3316                 if (nb_prom_envs >= MAX_PROM_ENVS) {
3317                     error_report("too many prom variables");
3318                     exit(1);
3319                 }
3320                 prom_envs[nb_prom_envs] = optarg;
3321                 nb_prom_envs++;
3322                 break;
3323             case QEMU_OPTION_old_param:
3324                 old_param = 1;
3325                 break;
3326             case QEMU_OPTION_rtc:
3327                 opts = qemu_opts_parse_noisily(qemu_find_opts("rtc"), optarg,
3328                                                false);
3329                 if (!opts) {
3330                     exit(1);
3331                 }
3332                 break;
3333             case QEMU_OPTION_icount:
3334                 icount_opts = qemu_opts_parse_noisily(qemu_find_opts("icount"),
3335                                                       optarg, true);
3336                 if (!icount_opts) {
3337                     exit(1);
3338                 }
3339                 break;
3340             case QEMU_OPTION_incoming:
3341                 if (!incoming) {
3342                     runstate_set(RUN_STATE_INMIGRATE);
3343                 }
3344                 incoming = optarg;
3345                 break;
3346             case QEMU_OPTION_only_migratable:
3347                 only_migratable = 1;
3348                 break;
3349             case QEMU_OPTION_nodefaults:
3350                 has_defaults = 0;
3351                 break;
3352             case QEMU_OPTION_xen_domid:
3353                 if (!(accel_find("xen"))) {
3354                     error_report("Option not supported for this target");
3355                     exit(1);
3356                 }
3357                 xen_domid = atoi(optarg);
3358                 break;
3359             case QEMU_OPTION_xen_attach:
3360                 if (!(accel_find("xen"))) {
3361                     error_report("Option not supported for this target");
3362                     exit(1);
3363                 }
3364                 xen_mode = XEN_ATTACH;
3365                 break;
3366             case QEMU_OPTION_xen_domid_restrict:
3367                 if (!(accel_find("xen"))) {
3368                     error_report("Option not supported for this target");
3369                     exit(1);
3370                 }
3371                 xen_domid_restrict = true;
3372                 break;
3373             case QEMU_OPTION_trace:
3374                 trace_opt_parse(optarg);
3375                 break;
3376             case QEMU_OPTION_plugin:
3377                 qemu_plugin_opt_parse(optarg, &plugin_list);
3378                 break;
3379             case QEMU_OPTION_readconfig:
3380                 qemu_read_config_file(optarg, qemu_parse_config_group, &error_fatal);
3381                 break;
3382 #ifdef CONFIG_SPICE
3383             case QEMU_OPTION_spice:
3384                 olist = qemu_find_opts_err("spice", NULL);
3385                 if (!olist) {
3386                     error_report("spice support is disabled");
3387                     exit(1);
3388                 }
3389                 opts = qemu_opts_parse_noisily(olist, optarg, false);
3390                 if (!opts) {
3391                     exit(1);
3392                 }
3393                 display_remote++;
3394                 break;
3395 #endif
3396             case QEMU_OPTION_qtest:
3397                 qtest_chrdev = optarg;
3398                 break;
3399             case QEMU_OPTION_qtest_log:
3400                 qtest_log = optarg;
3401                 break;
3402             case QEMU_OPTION_sandbox:
3403                 olist = qemu_find_opts("sandbox");
3404                 if (!olist) {
3405 #ifndef CONFIG_SECCOMP
3406                     error_report("-sandbox support is not enabled "
3407                                  "in this QEMU binary");
3408 #endif
3409                     exit(1);
3410                 }
3411
3412                 opts = qemu_opts_parse_noisily(olist, optarg, true);
3413                 if (!opts) {
3414                     exit(1);
3415                 }
3416                 break;
3417             case QEMU_OPTION_add_fd:
3418 #ifndef _WIN32
3419                 opts = qemu_opts_parse_noisily(qemu_find_opts("add-fd"),
3420                                                optarg, false);
3421                 if (!opts) {
3422                     exit(1);
3423                 }
3424 #else
3425                 error_report("File descriptor passing is disabled on this "
3426                              "platform");
3427                 exit(1);
3428 #endif
3429                 break;
3430             case QEMU_OPTION_object:
3431                 object_option_parse(optarg);
3432                 break;
3433             case QEMU_OPTION_overcommit:
3434                 opts = qemu_opts_parse_noisily(qemu_find_opts("overcommit"),
3435                                                optarg, false);
3436                 if (!opts) {
3437                     exit(1);
3438                 }
3439                 enable_mlock = qemu_opt_get_bool(opts, "mem-lock", false);
3440                 enable_cpu_pm = qemu_opt_get_bool(opts, "cpu-pm", false);
3441                 break;
3442             case QEMU_OPTION_compat:
3443                 {
3444                     CompatPolicy *opts;
3445                     Visitor *v;
3446
3447                     v = qobject_input_visitor_new_str(optarg, NULL,
3448                                                       &error_fatal);
3449
3450                     visit_type_CompatPolicy(v, NULL, &opts, &error_fatal);
3451                     QAPI_CLONE_MEMBERS(CompatPolicy, &compat_policy, opts);
3452
3453                     qapi_free_CompatPolicy(opts);
3454                     visit_free(v);
3455                     break;
3456                 }
3457             case QEMU_OPTION_msg:
3458                 opts = qemu_opts_parse_noisily(qemu_find_opts("msg"), optarg,
3459                                                false);
3460                 if (!opts) {
3461                     exit(1);
3462                 }
3463                 configure_msg(opts);
3464                 break;
3465             case QEMU_OPTION_dump_vmstate:
3466                 if (vmstate_dump_file) {
3467                     error_report("only one '-dump-vmstate' "
3468                                  "option may be given");
3469                     exit(1);
3470                 }
3471                 vmstate_dump_file = fopen(optarg, "w");
3472                 if (vmstate_dump_file == NULL) {
3473                     error_report("open %s: %s", optarg, strerror(errno));
3474                     exit(1);
3475                 }
3476                 break;
3477             case QEMU_OPTION_enable_sync_profile:
3478                 qsp_enable();
3479                 break;
3480             case QEMU_OPTION_nouserconfig:
3481                 /* Nothing to be parsed here. Especially, do not error out below. */
3482                 break;
3483             default:
3484                 if (os_parse_cmd_args(popt->index, optarg)) {
3485                     error_report("Option not supported in this build");
3486                     exit(1);
3487                 }
3488             }
3489         }
3490     }
3491     /*
3492      * Clear error location left behind by the loop.
3493      * Best done right after the loop.  Do not insert code here!
3494      */
3495     loc_set_none();
3496
3497     qemu_validate_options(machine_opts_dict);
3498     qemu_process_sugar_options();
3499
3500     /*
3501      * These options affect everything else and should be processed
3502      * before daemonizing.
3503      */
3504     qemu_process_early_options();
3505
3506     qemu_process_help_options();
3507     qemu_maybe_daemonize(pid_file);
3508
3509     /*
3510      * The trace backend must be initialized after daemonizing.
3511      * trace_init_backends() will call st_init(), which will create the
3512      * trace thread in the parent, and also register st_flush_trace_buffer()
3513      * in atexit(). This function will force the parent to wait for the
3514      * writeout thread to finish, which will not occur, and the parent
3515      * process will be left in the host.
3516      */
3517     if (!trace_init_backends()) {
3518         exit(1);
3519     }
3520     trace_init_file();
3521
3522     qemu_init_main_loop(&error_fatal);
3523     cpu_timers_init();
3524
3525     user_register_global_props();
3526     replay_configure(icount_opts);
3527
3528     configure_rtc(qemu_find_opts_singleton("rtc"));
3529
3530     /* Transfer QemuOpts options into machine options */
3531     parse_memory_options();
3532
3533     qemu_create_machine(machine_opts_dict);
3534
3535     suspend_mux_open();
3536
3537     qemu_disable_default_devices();
3538     qemu_create_default_devices();
3539     qemu_create_early_backends();
3540
3541     qemu_apply_legacy_machine_options(machine_opts_dict);
3542     qemu_apply_machine_options(machine_opts_dict);
3543     qobject_unref(machine_opts_dict);
3544     phase_advance(PHASE_MACHINE_CREATED);
3545
3546     /*
3547      * Note: uses machine properties such as kernel-irqchip, must run
3548      * after qemu_apply_machine_options.
3549      */
3550     configure_accelerators(argv[0]);
3551     phase_advance(PHASE_ACCEL_CREATED);
3552
3553     /*
3554      * Beware, QOM objects created before this point miss global and
3555      * compat properties.
3556      *
3557      * Global properties get set up by qdev_prop_register_global(),
3558      * called from user_register_global_props(), and certain option
3559      * desugaring.  Also in CPU feature desugaring (buried in
3560      * parse_cpu_option()), which happens below this point, but may
3561      * only target the CPU type, which can only be created after
3562      * parse_cpu_option() returned the type.
3563      *
3564      * Machine compat properties: object_set_machine_compat_props().
3565      * Accelerator compat props: object_set_accelerator_compat_props(),
3566      * called from do_configure_accelerator().
3567      */
3568
3569     machine_class = MACHINE_GET_CLASS(current_machine);
3570     if (!qtest_enabled() && machine_class->deprecation_reason) {
3571         warn_report("Machine type '%s' is deprecated: %s",
3572                      machine_class->name, machine_class->deprecation_reason);
3573     }
3574
3575     /*
3576      * Note: creates a QOM object, must run only after global and
3577      * compat properties have been set up.
3578      */
3579     migration_object_init();
3580
3581     qemu_create_late_backends();
3582
3583     /* parse features once if machine provides default cpu_type */
3584     current_machine->cpu_type = machine_class->default_cpu_type;
3585     if (cpu_option) {
3586         current_machine->cpu_type = parse_cpu_option(cpu_option);
3587     }
3588     /* NB: for machine none cpu_type could STILL be NULL here! */
3589
3590     qemu_resolve_machine_memdev();
3591     parse_numa_opts(current_machine);
3592
3593     if (vmstate_dump_file) {
3594         /* dump and exit */
3595         module_load_qom_all();
3596         dump_vmstate_json_to_file(vmstate_dump_file);
3597         exit(0);
3598     }
3599
3600     if (!preconfig_requested) {
3601         qmp_x_exit_preconfig(&error_fatal);
3602     }
3603     qemu_init_displays();
3604     accel_setup_post(current_machine);
3605     os_setup_post();
3606     resume_mux_open();
3607 }