1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
140typedef struct BlockdevOptionsQueueEntry {
141 BlockdevOptions *bdo;
142 Location loc;
143 QSIMPLEQ_ENTRY(BlockdevOptionsQueueEntry) entry;
144} BlockdevOptionsQueueEntry;
145
146typedef QSIMPLEQ_HEAD(, BlockdevOptionsQueueEntry) BlockdevOptionsQueue;
147
148typedef struct ObjectOption {
149 ObjectOptions *opts;
150 QTAILQ_ENTRY(ObjectOption) next;
151} ObjectOption;
152
153typedef struct DeviceOption {
154 QDict *opts;
155 Location loc;
156 QTAILQ_ENTRY(DeviceOption) next;
157} DeviceOption;
158
159static const char *cpu_option;
160static const char *mem_path;
161static const char *incoming;
162static const char *loadvm;
163static const char *accelerators;
164static bool have_custom_ram_size;
165static const char *ram_memdev_id;
166static QDict *machine_opts_dict;
167static QTAILQ_HEAD(, ObjectOption) object_opts = QTAILQ_HEAD_INITIALIZER(object_opts);
168static QTAILQ_HEAD(, DeviceOption) device_opts = QTAILQ_HEAD_INITIALIZER(device_opts);
169static int display_remote;
170static int snapshot;
171static bool preconfig_requested;
172static QemuPluginList plugin_list = QTAILQ_HEAD_INITIALIZER(plugin_list);
173static BlockdevOptionsQueue bdo_queue = QSIMPLEQ_HEAD_INITIALIZER(bdo_queue);
174static bool nographic = false;
175static int mem_prealloc;
176static const char *vga_model = NULL;
177static DisplayOptions dpy;
178static int num_serial_hds;
179static Chardev **serial_hds;
180static const char *log_mask;
181static const char *log_file;
182static bool list_data_dirs;
183static const char *qtest_chrdev;
184static const char *qtest_log;
185
186static int has_defaults = 1;
187static int default_serial = 1;
188static int default_parallel = 1;
189static int default_monitor = 1;
190static int default_floppy = 1;
191static int default_cdrom = 1;
192static int default_sdcard = 1;
193static int default_vga = 1;
194static int default_net = 1;
195
196static 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
220static 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 { }
236 },
237};
238
239static 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 { }
252 },
253};
254
255static 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
262
263
264
265 { }
266 },
267};
268
269static 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 { }
298 },
299};
300
301static 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 { }
319 },
320};
321
322static 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
331static QemuOptsList qemu_tpmdev_opts = {
332 .name = "tpmdev",
333 .implied_opt_name = "type",
334 .head = QTAILQ_HEAD_INITIALIZER(qemu_tpmdev_opts.head),
335 .desc = {
336
337 { }
338 },
339};
340
341static 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 { }
354 },
355};
356
357static 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 { }
372 },
373};
374
375static 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 { }
399 },
400};
401
402static 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 { }
421 },
422};
423
424static 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 { }
450 },
451};
452
453static 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 { }
478 },
479};
480
481static 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 { }
500 },
501};
502
503const char *qemu_get_vm_name(void)
504{
505 return qemu_name;
506}
507
508static 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
523static 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
531static 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
541static 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
558bool defaults_enabled(void)
559{
560 return has_defaults;
561}
562
563#ifndef _WIN32
564static 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
587
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
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
621static 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
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
642static 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
649static 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
657static 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
677static void configure_blockdev(BlockdevOptionsQueue *bdo_queue,
678 MachineClass *machine_class, int snapshot)
679{
680
681
682
683
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
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
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
718static 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 { }
747 },
748};
749
750static 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
761static 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
770
771static 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
786static 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
798
799static 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
814static 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
831static void version(void)
832{
833 printf("QEMU emulator version " QEMU_FULL_VERSION "\n"
834 QEMU_COPYRIGHT "\n");
835}
836
837static 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
870typedef struct QEMUOption {
871 const char *name;
872 int flags;
873 int index;
874 uint32_t arch_mask;
875} QEMUOption;
876
877static 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
889typedef struct VGAInterfaceInfo {
890 const char *opt_name;
891 const char *name;
892
893
894 const char *class_names[2];
895} VGAInterfaceInfo;
896
897static 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
945static 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
955static const char *
956get_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
969static 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
1021static 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
1035DisplayOptions *qmp_query_display_options(Error **errp)
1036{
1037 return QAPI_CLONE(DisplayOptions, &dpy);
1038}
1039
1040static 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
1052
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
1065static inline bool nonempty_str(const char *str)
1066{
1067 return str && *str;
1068}
1069
1070static 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
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
1101
1102
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);
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
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
1131static int device_help_func(void *opaque, QemuOpts *opts, Error **errp)
1132{
1133 return qdev_device_help(opts);
1134}
1135
1136static 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
1150static 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
1165static int fsdev_init_func(void *opaque, QemuOpts *opts, Error **errp)
1166{
1167 return qemu_fsdev_add(opts, errp);
1168}
1169#endif
1170
1171static int mon_init_func(void *opaque, QemuOpts *opts, Error **errp)
1172{
1173 return monitor_init_opts(opts, errp);
1174}
1175
1176static 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
1206struct device_config {
1207 enum {
1208 DEV_USB,
1209 DEV_SERIAL,
1210 DEV_PARALLEL,
1211 DEV_DEBUGCON,
1212 DEV_GDB,
1213 DEV_SCLP,
1214 } type;
1215 const char *cmdline;
1216 Location loc;
1217 QTAILQ_ENTRY(device_config) next;
1218};
1219
1220static QTAILQ_HEAD(, device_config) device_configs =
1221 QTAILQ_HEAD_INITIALIZER(device_configs);
1222
1223static 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
1234static 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
1252static 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
1288static void qemu_create_default_devices(void)
1289{
1290 MachineClass *machine_class = MACHINE_GET_CLASS(current_machine);
1291
1292 if (is_daemonized()) {
1293
1294
1295
1296
1297
1298
1299
1300
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
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
1363static 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
1383Chardev *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
1392static 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
1414static 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
1432static 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
1440
1441
1442 return strcmp(object_class_get_name(OBJECT_CLASS(mc1)),
1443 object_class_get_name(OBJECT_CLASS(mc2)));
1444 }
1445
1446
1447 return 1;
1448 }
1449
1450 if (mc2->family == NULL) {
1451
1452 return -1;
1453 }
1454
1455
1456 res = strcmp(mc1->family, mc2->family);
1457 if (res != 0) {
1458 return res;
1459 }
1460
1461
1462 return strcmp(object_class_get_name(OBJECT_CLASS(mc2)),
1463 object_class_get_name(OBJECT_CLASS(mc1)));
1464}
1465
1466static 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
1493static void
1494machine_merge_property(const char *propname, QDict *prop, Error **errp)
1495{
1496 QDict *opts;
1497
1498 opts = qdict_new();
1499
1500 qobject_ref(prop);
1501 qdict_put(opts, propname, prop);
1502 keyval_merge(machine_opts_dict, opts, errp);
1503 qobject_unref(opts);
1504}
1505
1506static void
1507machine_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
1522static const char *pid_file;
1523struct UnlinkPidfileNotifier {
1524 Notifier notifier;
1525 char *pid_file_realpath;
1526};
1527static struct UnlinkPidfileNotifier qemu_unlink_pidfile_notifier;
1528
1529static 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
1537static 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
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
1577static 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
1605static 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
1621static 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
1649static 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
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
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
1707static 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
1722static 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
1729static 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
1764
1765static bool object_create_pre_sandbox(const char *type)
1766{
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776 if (g_str_equal(type, "thread-context")) {
1777 return true;
1778 }
1779
1780 return false;
1781}
1782
1783
1784
1785
1786
1787
1788
1789
1790static bool object_create_early(const char *type)
1791{
1792
1793
1794
1795
1796
1797
1798 if (object_create_pre_sandbox(type)) {
1799 return false;
1800 }
1801
1802
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
1810 if (g_str_equal(type, "cryptodev-vhost-user")) {
1811 return false;
1812 }
1813#endif
1814
1815
1816 if (g_str_equal(type, "vhost-user-blk-server")) {
1817 return false;
1818 }
1819
1820
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
1834
1835
1836
1837
1838 if (g_str_has_prefix(type, "memory-backend-")) {
1839 return false;
1840 }
1841
1842 return true;
1843}
1844
1845static 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
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
1861static 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
1895
1896
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
1909
1910
1911 configure_blockdev(&bdo_queue, machine_class, snapshot);
1912 if (!audio_init_audiodevs()) {
1913 exit(1);
1914 }
1915}
1916
1917
1918
1919
1920
1921
1922static bool object_create_late(const char *type)
1923{
1924 return !object_create_early(type) && !object_create_pre_sandbox(type);
1925}
1926
1927static 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
1952 qemu_semihosting_chardev_init();
1953}
1954
1955static 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
1976static 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
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
2013static 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
2028
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
2043
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
2056static 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
2070
2071
2072static 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
2083static 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
2093
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
2108
2109
2110static 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
2136static 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
2151static 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
2179static void user_register_global_props(void)
2180{
2181 qemu_opts_foreach(qemu_find_opts("global"),
2182 global_init_func, NULL, NULL);
2183}
2184
2185static int do_configure_icount(void *opaque, QemuOpts *opts, Error **errp)
2186{
2187 icount_configure(opts, errp);
2188 return 0;
2189}
2190
2191static 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
2198static 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
2234static 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
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
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
2271
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
2306static 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
2342static 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
2359
2360
2361
2362
2363static 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
2378static 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
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
2421static void qemu_process_help_options(void)
2422{
2423
2424
2425
2426
2427
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
2440 if (list_data_dirs) {
2441 qemu_list_data_dirs();
2442 exit(0);
2443 }
2444}
2445
2446static 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
2479static void qemu_init_displays(void)
2480{
2481 DisplayState *ds;
2482
2483
2484 ds = init_displaystate();
2485 qemu_display_init(ds, &dpy);
2486
2487
2488 os_setup_signal_handling();
2489
2490
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
2501static void qemu_init_board(void)
2502{
2503
2504 qemu_plugin_load_list(&plugin_list, &error_fatal);
2505
2506
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
2515 hax_sync_vcpus();
2516 }
2517}
2518
2519static 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
2529 if (machine_usb(current_machine)) {
2530 if (foreach_device_config(DEV_USB, usb_parse) < 0)
2531 exit(1);
2532 }
2533
2534
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
2543
2544
2545
2546
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
2555static void qemu_machine_creation_done(void)
2556{
2557 MachineState *machine = MACHINE(qdev_get_machine());
2558
2559
2560 drive_check_orphaned();
2561
2562
2563
2564
2565
2566
2567
2568
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
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
2596void 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
2628void 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
2680 optind = 1;
2681 while (optind < argc) {
2682 if (argv[optind][0] != '-') {
2683
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
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
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
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
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
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
3493
3494
3495 loc_set_none();
3496
3497 qemu_validate_options(machine_opts_dict);
3498 qemu_process_sugar_options();
3499
3500
3501
3502
3503
3504 qemu_process_early_options();
3505
3506 qemu_process_help_options();
3507 qemu_maybe_daemonize(pid_file);
3508
3509
3510
3511
3512
3513
3514
3515
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
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
3548
3549
3550 configure_accelerators(argv[0]);
3551 phase_advance(PHASE_ACCEL_CREATED);
3552
3553
3554
3555
3556
3557
3558
3559
3560
3561
3562
3563
3564
3565
3566
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
3577
3578
3579 migration_object_init();
3580
3581 qemu_create_late_backends();
3582
3583
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
3589
3590 qemu_resolve_machine_memdev();
3591 parse_numa_opts(current_machine);
3592
3593 if (vmstate_dump_file) {
3594
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}
3608