vl.c (112095B)
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 }