vl.c 138.0 KB
Newer Older
1
/*
2
 * QEMU System Emulator
3
 *
B
bellard 已提交
4
 * Copyright (c) 2003-2008 Fabrice Bellard
5
 *
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
23
 */
24

P
Peter Maydell 已提交
25
#include "qemu/osdep.h"
26
#include "qemu/units.h"
27
#include "qapi/error.h"
28
#include "qemu-version.h"
29 30
#include "qemu/cutils.h"
#include "qemu/help_option.h"
F
Fam Zheng 已提交
31
#include "qemu/uuid.h"
32
#include "sysemu/seccomp.h"
33

B
bellard 已提交
34
#ifdef CONFIG_SDL
35
#if defined(__APPLE__) || defined(main)
S
Stefan Weil 已提交
36
#include <SDL.h>
M
malc 已提交
37 38 39
int qemu_main(int argc, char **argv, char **envp);
int main(int argc, char **argv)
{
40
    return qemu_main(argc, argv, NULL);
M
malc 已提交
41 42 43
}
#undef main
#define main qemu_main
B
bellard 已提交
44
#endif
B
bellard 已提交
45
#endif /* CONFIG_SDL */
46

47 48 49 50 51
#ifdef CONFIG_COCOA
#undef main
#define main qemu_main
#endif /* CONFIG_COCOA */

52

53
#include "qemu/error-report.h"
54
#include "qemu/sockets.h"
55 56
#include "hw/hw.h"
#include "hw/boards.h"
57
#include "sysemu/accel.h"
58
#include "hw/usb.h"
59
#include "hw/isa/isa.h"
60
#include "hw/scsi/scsi.h"
61
#include "hw/display/vga.h"
62
#include "hw/bt.h"
63
#include "sysemu/watchdog.h"
64
#include "hw/smbios/smbios.h"
65
#include "hw/acpi/acpi.h"
66
#include "hw/xen/xen.h"
67
#include "hw/qdev.h"
68
#include "hw/loader.h"
69
#include "monitor/qdev.h"
70
#include "sysemu/bt.h"
P
Paolo Bonzini 已提交
71
#include "net/net.h"
72
#include "net/slirp.h"
73
#include "monitor/monitor.h"
74
#include "ui/console.h"
75
#include "ui/input.h"
76
#include "sysemu/sysemu.h"
77
#include "sysemu/numa.h"
78
#include "exec/gdbstub.h"
79
#include "qemu/timer.h"
80
#include "chardev/char.h"
M
Michael Tokarev 已提交
81
#include "qemu/bitmap.h"
82
#include "qemu/log.h"
83
#include "sysemu/blockdev.h"
84
#include "hw/block/block.h"
85
#include "migration/misc.h"
86
#include "migration/snapshot.h"
87
#include "migration/global_state.h"
88
#include "sysemu/tpm.h"
89
#include "sysemu/dma.h"
90
#include "hw/audio/soundhw.h"
91
#include "audio/audio.h"
92
#include "sysemu/cpus.h"
93
#include "migration/colo.h"
94
#include "migration/postcopy-ram.h"
95
#include "sysemu/kvm.h"
96
#include "sysemu/hax.h"
97
#include "qapi/qobject-input-visitor.h"
98 99
#include "qemu/option.h"
#include "qemu/config-file.h"
100
#include "qemu-options.h"
101
#include "qemu/main-loop.h"
102
#ifdef CONFIG_VIRTFS
103 104
#include "fsdev/qemu-fsdev.h"
#endif
105
#include "sysemu/qtest.h"
106

107
#include "disas/disas.h"
B
bellard 已提交
108

109

J
Jan Kiszka 已提交
110
#include "slirp/libslirp.h"
111

112
#include "trace-root.h"
113
#include "trace/control.h"
114
#include "qemu/queue.h"
115
#include "sysemu/arch_init.h"
116

G
Gerd Hoffmann 已提交
117
#include "ui/qemu-spice.h"
118
#include "qapi/string-input-visitor.h"
P
Paolo Bonzini 已提交
119
#include "qapi/opts-visitor.h"
120
#include "qapi/clone-visitor.h"
121
#include "qom/object_interfaces.h"
122
#include "exec/semihost.h"
123
#include "crypto/init.h"
124
#include "sysemu/replay.h"
125 126
#include "qapi/qapi-events-run-state.h"
#include "qapi/qapi-visit-block-core.h"
127
#include "qapi/qapi-visit-ui.h"
128 129 130
#include "qapi/qapi-commands-block-core.h"
#include "qapi/qapi-commands-misc.h"
#include "qapi/qapi-commands-run-state.h"
131
#include "qapi/qapi-commands-ui.h"
132
#include "qapi/qmp/qerror.h"
133
#include "sysemu/iothread.h"
G
Gerd Hoffmann 已提交
134

135 136
#define MAX_VIRTIO_CONSOLES 1

137 138
static const char *data_dir[16];
static int data_dir_idx;
139
const char *bios_name = NULL;
140
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
141
int display_opengl;
142
const char* keyboard_layout = NULL;
143
ram_addr_t ram_size;
144 145
const char *mem_path = NULL;
int mem_prealloc = 0; /* force preallocation of physical target memory */
146
bool enable_mlock = false;
147
bool enable_cpu_pm = false;
148
int nb_nics;
B
bellard 已提交
149
NICInfo nd_table[MAX_NICS];
P
Paolo Bonzini 已提交
150
int autostart;
151 152 153 154 155
static enum {
    RTC_BASE_UTC,
    RTC_BASE_LOCALTIME,
    RTC_BASE_DATETIME,
} rtc_base_type = RTC_BASE_UTC;
156 157 158 159
static time_t rtc_ref_start_datetime;
static int rtc_realtime_clock_offset; /* used only with QEMU_CLOCK_REALTIME */
static int rtc_host_datetime_offset = -1; /* valid & used only with
                                             RTC_BASE_DATETIME */
160
QEMUClockType rtc_clock;
161
int vga_interface_type = VGA_NONE;
162
static DisplayOptions dpy;
163
int no_frame;
164 165
static int num_serial_hds;
static Chardev **serial_hds;
166 167
Chardev *parallel_hds[MAX_PARALLEL_PORTS];
Chardev *virtcon_hds[MAX_VIRTIO_CONSOLES];
168
int win2k_install_hack = 0;
169
int singlestep = 0;
170 171
int smp_cpus;
unsigned int max_cpus;
172 173
int smp_cores = 1;
int smp_threads = 1;
B
bellard 已提交
174
int acpi_enabled = 1;
175
int no_hpet = 0;
176
int fd_bootchk = 1;
B
Blue Swirl 已提交
177
static int no_reboot;
A
aurel32 已提交
178
int no_shutdown = 0;
179
int cursor_hide = 1;
180
int graphic_rotate = 0;
181
const char *watchdog;
182
QEMUOptionRom option_rom[MAX_OPTION_ROMS];
183
int nb_option_roms;
184
int old_param = 0;
185
const char *qemu_name;
186
int alt_grab = 0;
187
int ctrl_grab = 0;
188 189
unsigned int nb_prom_envs = 0;
const char *prom_envs[MAX_PROM_ENVS];
190
int boot_menu;
191
bool boot_strict;
192
uint8_t *boot_splash_filedata;
193
size_t boot_splash_filedata_size;
194
uint8_t qemu_extra_params_fw[2];
195
bool wakeup_suspend_enabled;
196

197
int icount_align_option;
198

199
/* The bytes in qemu_uuid are in the order specified by RFC4122, _not_ in the
200 201
 * little-endian "wire format" described in the SMBIOS 2.6 specification.
 */
202
QemuUUID qemu_uuid;
203
bool qemu_uuid_set;
204

G
Gerd Hoffmann 已提交
205 206 207
static NotifierList exit_notifiers =
    NOTIFIER_LIST_INITIALIZER(exit_notifiers);

208 209 210
static NotifierList machine_init_done_notifiers =
    NOTIFIER_LIST_INITIALIZER(machine_init_done_notifiers);

211
bool xen_allowed;
212 213
uint32_t xen_domid;
enum xen_mode xen_mode = XEN_EMULATE;
214
bool xen_domid_restrict;
215

216
static int has_defaults = 1;
217
static int default_serial = 1;
218
static int default_parallel = 1;
219
static int default_virtcon = 1;
220
static int default_monitor = 1;
221 222 223
static int default_floppy = 1;
static int default_cdrom = 1;
static int default_sdcard = 1;
224
static int default_vga = 1;
225
static int default_net = 1;
226 227 228 229 230

static struct {
    const char *driver;
    int *flag;
} default_list[] = {
231 232
    { .driver = "isa-serial",           .flag = &default_serial    },
    { .driver = "isa-parallel",         .flag = &default_parallel  },
233
    { .driver = "isa-fdc",              .flag = &default_floppy    },
234
    { .driver = "floppy",               .flag = &default_floppy    },
235 236
    { .driver = "ide-cd",               .flag = &default_cdrom     },
    { .driver = "ide-hd",               .flag = &default_cdrom     },
237
    { .driver = "ide-drive",            .flag = &default_cdrom     },
238
    { .driver = "scsi-cd",              .flag = &default_cdrom     },
239
    { .driver = "scsi-hd",              .flag = &default_cdrom     },
240 241
    { .driver = "virtio-serial-pci",    .flag = &default_virtcon   },
    { .driver = "virtio-serial",        .flag = &default_virtcon   },
242 243 244 245 246 247
    { .driver = "VGA",                  .flag = &default_vga       },
    { .driver = "isa-vga",              .flag = &default_vga       },
    { .driver = "cirrus-vga",           .flag = &default_vga       },
    { .driver = "isa-cirrus-vga",       .flag = &default_vga       },
    { .driver = "vmware-svga",          .flag = &default_vga       },
    { .driver = "qxl-vga",              .flag = &default_vga       },
248
    { .driver = "virtio-vga",           .flag = &default_vga       },
249 250
};

251 252 253
static QemuOptsList qemu_rtc_opts = {
    .name = "rtc",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_rtc_opts.head),
254
    .merge_lists = true,
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
    .desc = {
        {
            .name = "base",
            .type = QEMU_OPT_STRING,
        },{
            .name = "clock",
            .type = QEMU_OPT_STRING,
        },{
            .name = "driftfix",
            .type = QEMU_OPT_STRING,
        },
        { /* end of list */ }
    },
};

static QemuOptsList qemu_option_rom_opts = {
    .name = "option-rom",
    .implied_opt_name = "romfile",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_option_rom_opts.head),
    .desc = {
        {
            .name = "bootindex",
            .type = QEMU_OPT_NUMBER,
        }, {
            .name = "romfile",
            .type = QEMU_OPT_STRING,
        },
        { /* end of list */ }
    },
};

static QemuOptsList qemu_machine_opts = {
    .name = "machine",
    .implied_opt_name = "type",
    .merge_lists = true,
    .head = QTAILQ_HEAD_INITIALIZER(qemu_machine_opts.head),
    .desc = {
292 293 294 295 296 297
        /*
         * no elements => accept any
         * sanity checking will happen later
         * when setting machine properties
         */
        { }
298 299 300
    },
};

301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
static QemuOptsList qemu_accel_opts = {
    .name = "accel",
    .implied_opt_name = "accel",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_accel_opts.head),
    .merge_lists = true,
    .desc = {
        {
            .name = "accel",
            .type = QEMU_OPT_STRING,
            .help = "Select the type of accelerator",
        },
        {
            .name = "thread",
            .type = QEMU_OPT_STRING,
            .help = "Enable/disable multi-threaded TCG",
        },
        { /* end of list */ }
    },
};

321 322
static QemuOptsList qemu_boot_opts = {
    .name = "boot-opts",
323 324
    .implied_opt_name = "order",
    .merge_lists = true,
325 326 327 328 329 330 331 332 333 334
    .head = QTAILQ_HEAD_INITIALIZER(qemu_boot_opts.head),
    .desc = {
        {
            .name = "order",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "once",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "menu",
335
            .type = QEMU_OPT_BOOL,
336 337 338 339 340 341 342 343 344
        }, {
            .name = "splash",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "splash-time",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "reboot-timeout",
            .type = QEMU_OPT_STRING,
345 346
        }, {
            .name = "strict",
347
            .type = QEMU_OPT_BOOL,
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
        },
        { /*End of list */ }
    },
};

static QemuOptsList qemu_add_fd_opts = {
    .name = "add-fd",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_add_fd_opts.head),
    .desc = {
        {
            .name = "fd",
            .type = QEMU_OPT_NUMBER,
            .help = "file descriptor of which a duplicate is added to fd set",
        },{
            .name = "set",
            .type = QEMU_OPT_NUMBER,
            .help = "ID of the fd set to add fd to",
        },{
            .name = "opaque",
            .type = QEMU_OPT_STRING,
            .help = "free-form string used to describe fd",
        },
        { /* end of list */ }
    },
};

static QemuOptsList qemu_object_opts = {
    .name = "object",
    .implied_opt_name = "qom-type",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
    .desc = {
        { }
    },
};

383 384 385 386 387
static QemuOptsList qemu_tpmdev_opts = {
    .name = "tpmdev",
    .implied_opt_name = "type",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_tpmdev_opts.head),
    .desc = {
388
        /* options are defined in the TPM backends */
389 390 391 392
        { /* end of list */ }
    },
};

393 394 395 396 397 398 399 400 401 402 403 404
static QemuOptsList qemu_realtime_opts = {
    .name = "realtime",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_realtime_opts.head),
    .desc = {
        {
            .name = "mlock",
            .type = QEMU_OPT_BOOL,
        },
        { /* end of list */ }
    },
};

405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
static QemuOptsList qemu_overcommit_opts = {
    .name = "overcommit",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_overcommit_opts.head),
    .desc = {
        {
            .name = "mem-lock",
            .type = QEMU_OPT_BOOL,
        },
        {
            .name = "cpu-pm",
            .type = QEMU_OPT_BOOL,
        },
        { /* end of list */ }
    },
};

421 422 423 424 425 426 427 428 429 430 431 432
static QemuOptsList qemu_msg_opts = {
    .name = "msg",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_msg_opts.head),
    .desc = {
        {
            .name = "timestamp",
            .type = QEMU_OPT_BOOL,
        },
        { /* end of list */ }
    },
};

433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
static QemuOptsList qemu_name_opts = {
    .name = "name",
    .implied_opt_name = "guest",
    .merge_lists = true,
    .head = QTAILQ_HEAD_INITIALIZER(qemu_name_opts.head),
    .desc = {
        {
            .name = "guest",
            .type = QEMU_OPT_STRING,
            .help = "Sets the name of the guest.\n"
                    "This name will be displayed in the SDL window caption.\n"
                    "The name will also be used for the VNC server",
        }, {
            .name = "process",
            .type = QEMU_OPT_STRING,
            .help = "Sets the name of the QEMU process, as shown in top etc",
449 450 451 452 453 454
        }, {
            .name = "debug-threads",
            .type = QEMU_OPT_BOOL,
            .help = "When enabled, name the individual threads; defaults off.\n"
                    "NOTE: The thread names are for debugging and not a\n"
                    "stable API.",
455 456 457 458 459
        },
        { /* End of list */ }
    },
};

460 461 462 463 464 465 466 467 468 469
static QemuOptsList qemu_mem_opts = {
    .name = "memory",
    .implied_opt_name = "size",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_mem_opts.head),
    .merge_lists = true,
    .desc = {
        {
            .name = "size",
            .type = QEMU_OPT_SIZE,
        },
470 471 472 473 474 475 476 477
        {
            .name = "slots",
            .type = QEMU_OPT_NUMBER,
        },
        {
            .name = "maxmem",
            .type = QEMU_OPT_SIZE,
        },
478 479 480 481
        { /* end of list */ }
    },
};

482 483 484 485 486 487 488 489 490
static QemuOptsList qemu_icount_opts = {
    .name = "icount",
    .implied_opt_name = "shift",
    .merge_lists = true,
    .head = QTAILQ_HEAD_INITIALIZER(qemu_icount_opts.head),
    .desc = {
        {
            .name = "shift",
            .type = QEMU_OPT_STRING,
491 492 493
        }, {
            .name = "align",
            .type = QEMU_OPT_BOOL,
494 495 496
        }, {
            .name = "sleep",
            .type = QEMU_OPT_BOOL,
497 498 499 500 501 502
        }, {
            .name = "rr",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "rrfile",
            .type = QEMU_OPT_STRING,
503 504 505
        }, {
            .name = "rrsnapshot",
            .type = QEMU_OPT_STRING,
506 507 508 509 510
        },
        { /* end of list */ }
    },
};

511 512 513 514 515 516 517 518 519 520 521
static QemuOptsList qemu_semihosting_config_opts = {
    .name = "semihosting-config",
    .implied_opt_name = "enable",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_semihosting_config_opts.head),
    .desc = {
        {
            .name = "enable",
            .type = QEMU_OPT_BOOL,
        }, {
            .name = "target",
            .type = QEMU_OPT_STRING,
522 523 524
        }, {
            .name = "arg",
            .type = QEMU_OPT_STRING,
525 526 527 528 529
        },
        { /* end of list */ }
    },
};

530 531 532 533 534 535 536 537 538 539 540 541
static QemuOptsList qemu_fw_cfg_opts = {
    .name = "fw_cfg",
    .implied_opt_name = "name",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_fw_cfg_opts.head),
    .desc = {
        {
            .name = "name",
            .type = QEMU_OPT_STRING,
            .help = "Sets the fw_cfg name of the blob to be inserted",
        }, {
            .name = "file",
            .type = QEMU_OPT_STRING,
542
            .help = "Sets the name of the file from which "
543
                    "the fw_cfg blob will be loaded",
544 545 546 547
        }, {
            .name = "string",
            .type = QEMU_OPT_STRING,
            .help = "Sets content of the blob to be inserted from a string",
548 549 550 551 552
        },
        { /* end of list */ }
    },
};

553 554 555 556 557 558 559
/**
 * Get machine options
 *
 * Returns: machine options (never null).
 */
QemuOpts *qemu_get_machine_opts(void)
{
560
    return qemu_find_opts_singleton("machine");
561 562
}

563 564 565 566 567
const char *qemu_get_vm_name(void)
{
    return qemu_name;
}

568 569
static void res_free(void)
{
570 571
    g_free(boot_splash_filedata);
    boot_splash_filedata = NULL;
572 573
}

574
static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp)
575 576 577 578 579 580 581 582 583 584 585 586 587 588
{
    const char *driver = qemu_opt_get(opts, "driver");
    int i;

    if (!driver)
        return 0;
    for (i = 0; i < ARRAY_SIZE(default_list); i++) {
        if (strcmp(default_list[i].driver, driver) != 0)
            continue;
        *(default_list[i].flag) = 0;
    }
    return 0;
}

589 590 591
/***********************************************************/
/* QEMU state */

592
static RunState current_run_state = RUN_STATE_PRECONFIG;
593

594 595
/* We use RUN_STATE__MAX but any invalid value will do */
static RunState vmstop_requested = RUN_STATE__MAX;
596 597
static QemuMutex vmstop_lock;

598 599 600 601 602 603 604
typedef struct {
    RunState from;
    RunState to;
} RunStateTransition;

static const RunStateTransition runstate_transitions_def[] = {
    /*     from      ->     to      */
605 606 607 608 609 610 611
    { RUN_STATE_PRECONFIG, RUN_STATE_PRELAUNCH },
      /* Early switch to inmigrate state to allow  -incoming CLI option work
       * as it used to. TODO: delay actual switching to inmigrate state to
       * the point after machine is built and remove this hack.
       */
    { RUN_STATE_PRECONFIG, RUN_STATE_INMIGRATE },

612
    { RUN_STATE_DEBUG, RUN_STATE_RUNNING },
613
    { RUN_STATE_DEBUG, RUN_STATE_FINISH_MIGRATE },
614
    { RUN_STATE_DEBUG, RUN_STATE_PRELAUNCH },
615

616 617
    { RUN_STATE_INMIGRATE, RUN_STATE_INTERNAL_ERROR },
    { RUN_STATE_INMIGRATE, RUN_STATE_IO_ERROR },
618
    { RUN_STATE_INMIGRATE, RUN_STATE_PAUSED },
619 620 621 622 623
    { RUN_STATE_INMIGRATE, RUN_STATE_RUNNING },
    { RUN_STATE_INMIGRATE, RUN_STATE_SHUTDOWN },
    { RUN_STATE_INMIGRATE, RUN_STATE_SUSPENDED },
    { RUN_STATE_INMIGRATE, RUN_STATE_WATCHDOG },
    { RUN_STATE_INMIGRATE, RUN_STATE_GUEST_PANICKED },
624
    { RUN_STATE_INMIGRATE, RUN_STATE_FINISH_MIGRATE },
625 626
    { RUN_STATE_INMIGRATE, RUN_STATE_PRELAUNCH },
    { RUN_STATE_INMIGRATE, RUN_STATE_POSTMIGRATE },
627
    { RUN_STATE_INMIGRATE, RUN_STATE_COLO },
628

629
    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED },
630
    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE },
631
    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PRELAUNCH },
632

633
    { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING },
634
    { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE },
635
    { RUN_STATE_IO_ERROR, RUN_STATE_PRELAUNCH },
636

637
    { RUN_STATE_PAUSED, RUN_STATE_RUNNING },
638
    { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE },
639
    { RUN_STATE_PAUSED, RUN_STATE_POSTMIGRATE },
640
    { RUN_STATE_PAUSED, RUN_STATE_PRELAUNCH },
641
    { RUN_STATE_PAUSED, RUN_STATE_COLO},
642

643
    { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING },
644
    { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE },
645
    { RUN_STATE_POSTMIGRATE, RUN_STATE_PRELAUNCH },
646

647
    { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING },
648
    { RUN_STATE_PRELAUNCH, RUN_STATE_FINISH_MIGRATE },
649
    { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE },
650

651
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING },
652
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PAUSED },
653
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE },
654
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PRELAUNCH },
655
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_COLO},
656

657
    { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING },
658
    { RUN_STATE_RESTORE_VM, RUN_STATE_PRELAUNCH },
659

660 661
    { RUN_STATE_COLO, RUN_STATE_RUNNING },

662 663 664 665 666 667 668 669 670
    { RUN_STATE_RUNNING, RUN_STATE_DEBUG },
    { RUN_STATE_RUNNING, RUN_STATE_INTERNAL_ERROR },
    { RUN_STATE_RUNNING, RUN_STATE_IO_ERROR },
    { RUN_STATE_RUNNING, RUN_STATE_PAUSED },
    { RUN_STATE_RUNNING, RUN_STATE_FINISH_MIGRATE },
    { RUN_STATE_RUNNING, RUN_STATE_RESTORE_VM },
    { RUN_STATE_RUNNING, RUN_STATE_SAVE_VM },
    { RUN_STATE_RUNNING, RUN_STATE_SHUTDOWN },
    { RUN_STATE_RUNNING, RUN_STATE_WATCHDOG },
671
    { RUN_STATE_RUNNING, RUN_STATE_GUEST_PANICKED },
672
    { RUN_STATE_RUNNING, RUN_STATE_COLO},
673

674
    { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING },
675

676
    { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
677
    { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE },
678
    { RUN_STATE_SHUTDOWN, RUN_STATE_PRELAUNCH },
679

680 681 682 683
    { RUN_STATE_DEBUG, RUN_STATE_SUSPENDED },
    { RUN_STATE_RUNNING, RUN_STATE_SUSPENDED },
    { RUN_STATE_SUSPENDED, RUN_STATE_RUNNING },
    { RUN_STATE_SUSPENDED, RUN_STATE_FINISH_MIGRATE },
684
    { RUN_STATE_SUSPENDED, RUN_STATE_PRELAUNCH },
685
    { RUN_STATE_SUSPENDED, RUN_STATE_COLO},
686

687
    { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
688
    { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },
689
    { RUN_STATE_WATCHDOG, RUN_STATE_PRELAUNCH },
690
    { RUN_STATE_WATCHDOG, RUN_STATE_COLO},
691

692
    { RUN_STATE_GUEST_PANICKED, RUN_STATE_RUNNING },
693
    { RUN_STATE_GUEST_PANICKED, RUN_STATE_FINISH_MIGRATE },
694
    { RUN_STATE_GUEST_PANICKED, RUN_STATE_PRELAUNCH },
695

696
    { RUN_STATE__MAX, RUN_STATE__MAX },
697 698
};

699
static bool runstate_valid_transitions[RUN_STATE__MAX][RUN_STATE__MAX];
700

701 702 703 704 705
bool runstate_check(RunState state)
{
    return current_run_state == state;
}

706 707
bool runstate_store(char *str, size_t size)
{
708
    const char *state = RunState_str(current_run_state);
709 710 711 712 713 714 715 716 717
    size_t len = strlen(state) + 1;

    if (len > size) {
        return false;
    }
    memcpy(str, state, len);
    return true;
}

B
Blue Swirl 已提交
718
static void runstate_init(void)
719 720 721 722
{
    const RunStateTransition *p;

    memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions));
723
    for (p = &runstate_transitions_def[0]; p->from != RUN_STATE__MAX; p++) {
724 725
        runstate_valid_transitions[p->from][p->to] = true;
    }
726 727

    qemu_mutex_init(&vmstop_lock);
728 729 730
}

/* This function will abort() on invalid state transitions */
731 732
void runstate_set(RunState new_state)
{
733
    assert(new_state < RUN_STATE__MAX);
734

735 736 737 738
    if (current_run_state == new_state) {
        return;
    }

739
    if (!runstate_valid_transitions[current_run_state][new_state]) {
740
        error_report("invalid runstate transition: '%s' -> '%s'",
741 742
                     RunState_str(current_run_state),
                     RunState_str(new_state));
743 744
        abort();
    }
745
    trace_runstate_set(new_state);
746 747 748
    current_run_state = new_state;
}

749
int runstate_is_running(void)
750
{
751
    return runstate_check(RUN_STATE_RUNNING);
752 753
}

754 755 756
bool runstate_needs_reset(void)
{
    return runstate_check(RUN_STATE_INTERNAL_ERROR) ||
757
        runstate_check(RUN_STATE_SHUTDOWN);
758 759
}

760
StatusInfo *qmp_query_status(Error **errp)
761
{
762 763 764 765 766 767 768
    StatusInfo *info = g_malloc0(sizeof(*info));

    info->running = runstate_is_running();
    info->singlestep = singlestep;
    info->status = current_run_state;

    return info;
769 770
}

771
bool qemu_vmstop_requested(RunState *r)
772 773 774
{
    qemu_mutex_lock(&vmstop_lock);
    *r = vmstop_requested;
775
    vmstop_requested = RUN_STATE__MAX;
776
    qemu_mutex_unlock(&vmstop_lock);
777
    return *r < RUN_STATE__MAX;
778 779 780 781 782 783 784 785 786 787 788 789 790 791
}

void qemu_system_vmstop_request_prepare(void)
{
    qemu_mutex_lock(&vmstop_lock);
}

void qemu_system_vmstop_request(RunState state)
{
    vmstop_requested = state;
    qemu_mutex_unlock(&vmstop_lock);
    qemu_notify_event();
}

792
/***********************************************************/
793
/* RTC reference time/date access */
794
static time_t qemu_ref_timedate(QEMUClockType clock)
795
{
796 797
    time_t value = qemu_clock_get_ms(clock) / 1000;
    switch (clock) {
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
    case QEMU_CLOCK_REALTIME:
        value -= rtc_realtime_clock_offset;
        /* no break */
    case QEMU_CLOCK_VIRTUAL:
        value += rtc_ref_start_datetime;
        break;
    case QEMU_CLOCK_HOST:
        if (rtc_base_type == RTC_BASE_DATETIME) {
            value -= rtc_host_datetime_offset;
        }
        break;
    default:
        assert(0);
    }
    return value;
813 814
}

815 816
void qemu_get_timedate(struct tm *tm, int offset)
{
817
    time_t ti = qemu_ref_timedate(rtc_clock);
818 819

    ti += offset;
820 821

    switch (rtc_base_type) {
822
    case RTC_BASE_DATETIME:
823
    case RTC_BASE_UTC:
824
        gmtime_r(&ti, tm);
825 826 827 828
        break;
    case RTC_BASE_LOCALTIME:
        localtime_r(&ti, tm);
        break;
829 830 831 832 833 834 835
    }
}

int qemu_timedate_diff(struct tm *tm)
{
    time_t seconds;

836
    switch (rtc_base_type) {
837
    case RTC_BASE_DATETIME:
838 839 840 841 842 843 844 845 846 847 848 849 850
    case RTC_BASE_UTC:
        seconds = mktimegm(tm);
        break;
    case RTC_BASE_LOCALTIME:
    {
        struct tm tmp = *tm;
        tmp.tm_isdst = -1; /* use timezone to figure it out */
        seconds = mktime(&tmp);
        break;
    }
    default:
        abort();
    }
851

852
    return seconds - qemu_ref_timedate(QEMU_CLOCK_HOST);
853 854
}

855
static void configure_rtc_base_datetime(const char *startdate)
856
{
857
    time_t rtc_start_datetime;
858 859
    struct tm tm;

860 861 862 863 864 865 866 867
    if (sscanf(startdate, "%d-%d-%dT%d:%d:%d", &tm.tm_year, &tm.tm_mon,
               &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec) == 6) {
        /* OK */
    } else if (sscanf(startdate, "%d-%d-%d",
                      &tm.tm_year, &tm.tm_mon, &tm.tm_mday) == 3) {
        tm.tm_hour = 0;
        tm.tm_min = 0;
        tm.tm_sec = 0;
868
    } else {
869 870 871 872
        goto date_fail;
    }
    tm.tm_year -= 1900;
    tm.tm_mon--;
873 874
    rtc_start_datetime = mktimegm(&tm);
    if (rtc_start_datetime == -1) {
875
    date_fail:
876
        error_report("invalid datetime format");
877 878 879
        error_printf("valid formats: "
                     "'2006-06-17T16:01:21' or '2006-06-17'\n");
        exit(1);
880
    }
881 882
    rtc_host_datetime_offset = rtc_ref_start_datetime - rtc_start_datetime;
    rtc_ref_start_datetime = rtc_start_datetime;
883 884 885 886 887 888
}

static void configure_rtc(QemuOpts *opts)
{
    const char *value;

889 890 891 892 893
    /* Set defaults */
    rtc_clock = QEMU_CLOCK_HOST;
    rtc_ref_start_datetime = qemu_clock_get_ms(QEMU_CLOCK_HOST) / 1000;
    rtc_realtime_clock_offset = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) / 1000;

894 895 896
    value = qemu_opt_get(opts, "base");
    if (value) {
        if (!strcmp(value, "utc")) {
897
            rtc_base_type = RTC_BASE_UTC;
898
        } else if (!strcmp(value, "localtime")) {
899
            Error *blocker = NULL;
900
            rtc_base_type = RTC_BASE_LOCALTIME;
901 902 903
            error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED,
                      "-rtc base=localtime");
            replay_add_blocker(blocker);
904
        } else {
905
            rtc_base_type = RTC_BASE_DATETIME;
906
            configure_rtc_base_datetime(value);
907 908
        }
    }
J
Jan Kiszka 已提交
909 910 911
    value = qemu_opt_get(opts, "clock");
    if (value) {
        if (!strcmp(value, "host")) {
912
            rtc_clock = QEMU_CLOCK_HOST;
P
Paolo Bonzini 已提交
913
        } else if (!strcmp(value, "rt")) {
914
            rtc_clock = QEMU_CLOCK_REALTIME;
J
Jan Kiszka 已提交
915
        } else if (!strcmp(value, "vm")) {
916
            rtc_clock = QEMU_CLOCK_VIRTUAL;
J
Jan Kiszka 已提交
917
        } else {
918
            error_report("invalid option value '%s'", value);
J
Jan Kiszka 已提交
919 920 921
            exit(1);
        }
    }
922 923
    value = qemu_opt_get(opts, "driftfix");
    if (value) {
B
Blue Swirl 已提交
924
        if (!strcmp(value, "slew")) {
925 926 927 928
            static GlobalProperty slew_lost_ticks = {
                .driver   = "mc146818rtc",
                .property = "lost_tick_policy",
                .value    = "slew",
929 930
            };

931
            qdev_prop_register_global(&slew_lost_ticks);
B
Blue Swirl 已提交
932
        } else if (!strcmp(value, "none")) {
933
            /* discard is default */
934
        } else {
935
            error_report("invalid option value '%s'", value);
936 937 938 939 940
            exit(1);
        }
    }
}

941 942 943 944 945
/***********************************************************/
/* Bluetooth support */
static int nb_hcis;
static int cur_hci;
static struct HCIInfo *hci_table[MAX_NICS];
946

947 948 949 950 951 952 953 954
struct HCIInfo *qemu_next_hci(void)
{
    if (cur_hci == nb_hcis)
        return &null_hci;

    return hci_table[cur_hci++];
}

955 956 957
static int bt_hci_parse(const char *str)
{
    struct HCIInfo *hci;
958
    bdaddr_t bdaddr;
959 960

    if (nb_hcis >= MAX_NICS) {
961
        error_report("too many bluetooth HCIs (max %i)", MAX_NICS);
962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986
        return -1;
    }

    hci = hci_init(str);
    if (!hci)
        return -1;

    bdaddr.b[0] = 0x52;
    bdaddr.b[1] = 0x54;
    bdaddr.b[2] = 0x00;
    bdaddr.b[3] = 0x12;
    bdaddr.b[4] = 0x34;
    bdaddr.b[5] = 0x56 + nb_hcis;
    hci->bdaddr_set(hci, bdaddr.b);

    hci_table[nb_hcis++] = hci;

    return 0;
}

static void bt_vhci_add(int vlan_id)
{
    struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);

    if (!vlan->slave)
987 988
        warn_report("adding a VHCI to an empty scatternet %i",
                    vlan_id);
989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005

    bt_vhci_init(bt_new_hci(vlan));
}

static struct bt_device_s *bt_device_add(const char *opt)
{
    struct bt_scatternet_s *vlan;
    int vlan_id = 0;
    char *endp = strstr(opt, ",vlan=");
    int len = (endp ? endp - opt : strlen(opt)) + 1;
    char devname[10];

    pstrcpy(devname, MIN(sizeof(devname), len), opt);

    if (endp) {
        vlan_id = strtol(endp + 6, &endp, 0);
        if (*endp) {
1006
            error_report("unrecognised bluetooth vlan Id");
1007 1008 1009 1010 1011 1012 1013
            return 0;
        }
    }

    vlan = qemu_find_bt_vlan(vlan_id);

    if (!vlan->slave)
1014 1015
        warn_report("adding a slave device to an empty scatternet %i",
                    vlan_id);
1016 1017 1018 1019

    if (!strcmp(devname, "keyboard"))
        return bt_keyboard_init(vlan);

1020
    error_report("unsupported bluetooth device '%s'", devname);
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
    return 0;
}

static int bt_parse(const char *opt)
{
    const char *endp, *p;
    int vlan;

    if (strstart(opt, "hci", &endp)) {
        if (!*endp || *endp == ',') {
            if (*endp)
                if (!strstart(endp, ",vlan=", 0))
                    opt = endp + 1;

            return bt_hci_parse(opt);
       }
    } else if (strstart(opt, "vhci", &endp)) {
        if (!*endp || *endp == ',') {
            if (*endp) {
                if (strstart(endp, ",vlan=", &p)) {
                    vlan = strtol(p, (char **) &endp, 0);
                    if (*endp) {
1043
                        error_report("bad scatternet '%s'", p);
1044 1045 1046
                        return 1;
                    }
                } else {
1047
                    error_report("bad parameter '%s'", endp + 1);
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
                    return 1;
                }
            } else
                vlan = 0;

            bt_vhci_add(vlan);
            return 0;
        }
    } else if (strstart(opt, "device:", &endp))
        return !bt_device_add(endp);

1059
    error_report("bad bluetooth parameter '%s'", opt);
1060 1061 1062
    return 1;
}

1063
static int parse_name(void *opaque, QemuOpts *opts, Error **errp)
1064 1065 1066
{
    const char *proc_name;

1067 1068 1069
    if (qemu_opt_get(opts, "debug-threads")) {
        qemu_thread_naming(qemu_opt_get_bool(opts, "debug-threads", false));
    }
1070 1071 1072 1073 1074 1075
    qemu_name = qemu_opt_get(opts, "guest");

    proc_name = qemu_opt_get(opts, "process");
    if (proc_name) {
        os_set_proc_name(proc_name);
    }
1076 1077

    return 0;
1078 1079
}

1080 1081 1082 1083 1084
bool defaults_enabled(void)
{
    return has_defaults;
}

1085
#ifndef _WIN32
1086
static int parse_add_fd(void *opaque, QemuOpts *opts, Error **errp)
1087 1088 1089 1090
{
    int fd, dupfd, flags;
    int64_t fdset_id;
    const char *fd_opaque = NULL;
1091
    AddfdInfo *fdinfo;
1092 1093 1094 1095 1096 1097

    fd = qemu_opt_get_number(opts, "fd", -1);
    fdset_id = qemu_opt_get_number(opts, "set", -1);
    fd_opaque = qemu_opt_get(opts, "opaque");

    if (fd < 0) {
1098
        error_setg(errp, "fd option is required and must be non-negative");
1099 1100 1101 1102
        return -1;
    }

    if (fd <= STDERR_FILENO) {
1103
        error_setg(errp, "fd cannot be a standard I/O stream");
1104 1105 1106 1107 1108 1109 1110 1111 1112
        return -1;
    }

    /*
     * All fds inherited across exec() necessarily have FD_CLOEXEC
     * clear, while qemu sets FD_CLOEXEC on all other fds used internally.
     */
    flags = fcntl(fd, F_GETFD);
    if (flags == -1 || (flags & FD_CLOEXEC)) {
1113
        error_setg(errp, "fd is not valid or already in use");
1114 1115 1116 1117
        return -1;
    }

    if (fdset_id < 0) {
1118
        error_setg(errp, "set option is required and must be non-negative");
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
        return -1;
    }

#ifdef F_DUPFD_CLOEXEC
    dupfd = fcntl(fd, F_DUPFD_CLOEXEC, 0);
#else
    dupfd = dup(fd);
    if (dupfd != -1) {
        qemu_set_cloexec(dupfd);
    }
#endif
    if (dupfd == -1) {
1131
        error_setg(errp, "error duplicating fd: %s", strerror(errno));
1132 1133 1134 1135
        return -1;
    }

    /* add the duplicate fd, and optionally the opaque string, to the fd set */
1136 1137 1138
    fdinfo = monitor_fdset_add_fd(dupfd, true, fdset_id, !!fd_opaque, fd_opaque,
                                  &error_abort);
    g_free(fdinfo);
1139 1140 1141 1142

    return 0;
}

1143
static int cleanup_add_fd(void *opaque, QemuOpts *opts, Error **errp)
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153
{
    int fd;

    fd = qemu_opt_get_number(opts, "fd", -1);
    close(fd);

    return 0;
}
#endif

1154 1155 1156
/***********************************************************/
/* QEMU Block devices */

1157 1158 1159 1160 1161 1162
#define HD_OPTS "media=disk"
#define CDROM_OPTS "media=cdrom"
#define FD_OPTS ""
#define PFLASH_OPTS ""
#define MTD_OPTS ""
#define SD_OPTS ""
1163

1164
static int drive_init_func(void *opaque, QemuOpts *opts, Error **errp)
1165
{
1166
    BlockInterfaceType *block_default_type = opaque;
1167

1168
    return drive_new(opts, *block_default_type, errp) == NULL;
1169 1170
}

1171
static int drive_enable_snapshot(void *opaque, QemuOpts *opts, Error **errp)
1172
{
G
Gonglei 已提交
1173
    if (qemu_opt_get(opts, "snapshot") == NULL) {
1174
        qemu_opt_set(opts, "snapshot", "on", &error_abort);
1175 1176 1177 1178
    }
    return 0;
}

1179 1180
static void default_drive(int enable, int snapshot, BlockInterfaceType type,
                          int index, const char *optstr)
1181 1182
{
    QemuOpts *opts;
1183
    DriveInfo *dinfo;
1184 1185 1186 1187 1188 1189 1190

    if (!enable || drive_get_by_index(type, index)) {
        return;
    }

    opts = drive_add(type, index, NULL, optstr);
    if (snapshot) {
1191
        drive_enable_snapshot(NULL, opts, NULL);
1192
    }
1193

1194
    dinfo = drive_new(opts, type, &error_abort);
1195 1196
    dinfo->is_default = true;

1197 1198
}

1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
static QemuOptsList qemu_smp_opts = {
    .name = "smp-opts",
    .implied_opt_name = "cpus",
    .merge_lists = true,
    .head = QTAILQ_HEAD_INITIALIZER(qemu_smp_opts.head),
    .desc = {
        {
            .name = "cpus",
            .type = QEMU_OPT_NUMBER,
        }, {
            .name = "sockets",
            .type = QEMU_OPT_NUMBER,
        }, {
            .name = "cores",
            .type = QEMU_OPT_NUMBER,
        }, {
            .name = "threads",
            .type = QEMU_OPT_NUMBER,
        }, {
            .name = "maxcpus",
            .type = QEMU_OPT_NUMBER,
        },
        { /*End of list */ }
    },
};

static void smp_parse(QemuOpts *opts)
1226
{
1227 1228 1229 1230 1231 1232 1233 1234 1235
    if (opts) {
        unsigned cpus    = qemu_opt_get_number(opts, "cpus", 0);
        unsigned sockets = qemu_opt_get_number(opts, "sockets", 0);
        unsigned cores   = qemu_opt_get_number(opts, "cores", 0);
        unsigned threads = qemu_opt_get_number(opts, "threads", 0);

        /* compute missing values, prefer sockets over cores over threads */
        if (cpus == 0 || sockets == 0) {
            cores = cores > 0 ? cores : 1;
1236
            threads = threads > 0 ? threads : 1;
1237
            if (cpus == 0) {
1238
                sockets = sockets > 0 ? sockets : 1;
1239
                cpus = cores * threads * sockets;
1240 1241 1242
            } else {
                max_cpus = qemu_opt_get_number(opts, "maxcpus", cpus);
                sockets = max_cpus / (cores * threads);
1243
            }
1244 1245 1246
        } else if (cores == 0) {
            threads = threads > 0 ? threads : 1;
            cores = cpus / (sockets * threads);
1247
            cores = cores > 0 ? cores : 1;
1248
        } else if (threads == 0) {
1249
            threads = cpus / (cores * sockets);
1250
            threads = threads > 0 ? threads : 1;
1251
        } else if (sockets * cores * threads < cpus) {
1252 1253 1254 1255
            error_report("cpu topology: "
                         "sockets (%u) * cores (%u) * threads (%u) < "
                         "smp_cpus (%u)",
                         sockets, cores, threads, cpus);
1256
            exit(1);
1257
        }
1258

1259
        max_cpus = qemu_opt_get_number(opts, "maxcpus", cpus);
A
Andrew Jones 已提交
1260 1261 1262 1263 1264 1265

        if (max_cpus < cpus) {
            error_report("maxcpus must be equal to or greater than smp");
            exit(1);
        }

1266
        if (sockets * cores * threads > max_cpus) {
1267 1268 1269 1270
            error_report("cpu topology: "
                         "sockets (%u) * cores (%u) * threads (%u) > "
                         "maxcpus (%u)",
                         sockets, cores, threads, max_cpus);
1271 1272
            exit(1);
        }
1273

1274 1275 1276 1277 1278 1279 1280
        if (sockets * cores * threads != max_cpus) {
            warn_report("Invalid CPU topology deprecated: "
                        "sockets (%u) * cores (%u) * threads (%u) "
                        "!= maxcpus (%u)",
                        sockets, cores, threads, max_cpus);
        }

1281
        smp_cpus = cpus;
A
Andrew Jones 已提交
1282 1283
        smp_cores = cores;
        smp_threads = threads;
1284 1285
    }

A
Andrew Jones 已提交
1286
    if (smp_cpus > 1) {
1287 1288 1289 1290
        Error *blocker = NULL;
        error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED, "smp");
        replay_add_blocker(blocker);
    }
1291 1292
}

1293
static void realtime_init(void)
1294 1295 1296
{
    if (enable_mlock) {
        if (os_mlock() < 0) {
1297
            error_report("locking memory failed");
1298 1299 1300 1301 1302
            exit(1);
        }
    }
}

1303 1304 1305 1306 1307 1308

static void configure_msg(QemuOpts *opts)
{
    enable_timestamp_msg = qemu_opt_get_bool(opts, "timestamp", true);
}

1309 1310 1311 1312 1313 1314
/***********************************************************/
/* Semihosting */

typedef struct SemihostingConfig {
    bool enabled;
    SemihostingTarget target;
1315 1316 1317
    const char **argv;
    int argc;
    const char *cmdline; /* concatenated argv */
1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331
} SemihostingConfig;

static SemihostingConfig semihosting;

bool semihosting_enabled(void)
{
    return semihosting.enabled;
}

SemihostingTarget semihosting_get_target(void)
{
    return semihosting.target;
}

1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383
const char *semihosting_get_arg(int i)
{
    if (i >= semihosting.argc) {
        return NULL;
    }
    return semihosting.argv[i];
}

int semihosting_get_argc(void)
{
    return semihosting.argc;
}

const char *semihosting_get_cmdline(void)
{
    if (semihosting.cmdline == NULL && semihosting.argc > 0) {
        semihosting.cmdline = g_strjoinv(" ", (gchar **)semihosting.argv);
    }
    return semihosting.cmdline;
}

static int add_semihosting_arg(void *opaque,
                               const char *name, const char *val,
                               Error **errp)
{
    SemihostingConfig *s = opaque;
    if (strcmp(name, "arg") == 0) {
        s->argc++;
        /* one extra element as g_strjoinv() expects NULL-terminated array */
        s->argv = g_realloc(s->argv, (s->argc + 1) * sizeof(void *));
        s->argv[s->argc - 1] = val;
        s->argv[s->argc] = NULL;
    }
    return 0;
}

/* Use strings passed via -kernel/-append to initialize semihosting.argv[] */
static inline void semihosting_arg_fallback(const char *file, const char *cmd)
{
    char *cmd_token;

    /* argv[0] */
    add_semihosting_arg(&semihosting, "arg", file, NULL);

    /* split -append and initialize argv[1..n] */
    cmd_token = strtok(g_strdup(cmd), " ");
    while (cmd_token) {
        add_semihosting_arg(&semihosting, "arg", cmd_token, NULL);
        cmd_token = strtok(NULL, " ");
    }
}

1384 1385 1386 1387 1388 1389 1390
/* Now we still need this for compatibility with XEN. */
bool has_igd_gfx_passthru;
static void igd_gfx_passthru(void)
{
    has_igd_gfx_passthru = current_machine->igd_gfx_passthru;
}

B
bellard 已提交
1391 1392 1393
/***********************************************************/
/* USB devices */

1394
static int usb_device_add(const char *devname)
B
bellard 已提交
1395
{
1396
    USBDevice *dev = NULL;
B
bellard 已提交
1397

1398
    if (!machine_usb(current_machine)) {
B
bellard 已提交
1399
        return -1;
1400
    }
B
bellard 已提交
1401

1402
    dev = usbdevice_create(devname);
P
pbrook 已提交
1403 1404 1405
    if (!dev)
        return -1;

B
bellard 已提交
1406 1407 1408
    return 0;
}

1409 1410
static int usb_parse(const char *cmdline)
{
1411
    int r;
1412
    r = usb_device_add(cmdline);
1413
    if (r < 0) {
1414
        error_report("could not add USB device '%s'", cmdline);
1415 1416
    }
    return r;
1417 1418
}

1419 1420 1421
/***********************************************************/
/* machine registration */

1422
MachineState *current_machine;
1423

1424
static MachineClass *find_machine(const char *name)
1425
{
1426
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1427
    MachineClass *mc = NULL;
1428

1429
    for (el = machines; el; el = el->next) {
1430
        MachineClass *temp = el->data;
1431

1432
        if (!strcmp(temp->name, name)) {
1433
            mc = temp;
1434 1435
            break;
        }
1436 1437
        if (temp->alias &&
            !strcmp(temp->alias, name)) {
1438
            mc = temp;
1439 1440
            break;
        }
1441
    }
1442 1443

    g_slist_free(machines);
1444
    return mc;
1445 1446
}

1447
MachineClass *find_default_machine(void)
1448
{
1449
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1450
    MachineClass *mc = NULL;
1451

1452
    for (el = machines; el; el = el->next) {
1453
        MachineClass *temp = el->data;
1454

1455
        if (temp->is_default) {
1456
            mc = temp;
1457
            break;
1458 1459
        }
    }
1460 1461

    g_slist_free(machines);
1462
    return mc;
1463 1464
}

1465 1466
MachineInfoList *qmp_query_machines(Error **errp)
{
1467
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1468 1469
    MachineInfoList *mach_list = NULL;

1470 1471
    for (el = machines; el; el = el->next) {
        MachineClass *mc = el->data;
1472 1473 1474 1475
        MachineInfoList *entry;
        MachineInfo *info;

        info = g_malloc0(sizeof(*info));
1476
        if (mc->is_default) {
1477 1478 1479 1480
            info->has_is_default = true;
            info->is_default = true;
        }

1481
        if (mc->alias) {
1482
            info->has_alias = true;
1483
            info->alias = g_strdup(mc->alias);
1484 1485
        }

1486 1487
        info->name = g_strdup(mc->name);
        info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
1488
        info->hotpluggable_cpus = mc->has_hotpluggable_cpus;
1489 1490 1491 1492 1493 1494 1495

        entry = g_malloc0(sizeof(*entry));
        entry->value = info;
        entry->next = mach_list;
        mach_list = entry;
    }

1496
    g_slist_free(machines);
1497 1498 1499
    return mach_list;
}

1500 1501 1502
static int machine_help_func(QemuOpts *opts, MachineState *machine)
{
    ObjectProperty *prop;
1503
    ObjectPropertyIterator iter;
1504 1505 1506 1507 1508

    if (!qemu_opt_has_help_opt(opts)) {
        return 0;
    }

1509 1510
    object_property_iter_init(&iter, OBJECT(machine));
    while ((prop = object_property_iter_next(&iter))) {
1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
        if (!prop->set) {
            continue;
        }

        error_printf("%s.%s=%s", MACHINE_GET_CLASS(machine)->name,
                     prop->name, prop->type);
        if (prop->description) {
            error_printf(" (%s)\n", prop->description);
        } else {
            error_printf("\n");
        }
    }

    return 1;
}

1527 1528 1529
struct vm_change_state_entry {
    VMChangeStateHandler *cb;
    void *opaque;
1530
    QLIST_ENTRY (vm_change_state_entry) entries;
1531 1532
};

1533
static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
1534 1535 1536 1537 1538 1539

VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
                                                     void *opaque)
{
    VMChangeStateEntry *e;

1540
    e = g_malloc0(sizeof (*e));
1541 1542 1543

    e->cb = cb;
    e->opaque = opaque;
1544
    QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
1545 1546 1547 1548 1549
    return e;
}

void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
{
1550
    QLIST_REMOVE (e, entries);
1551
    g_free (e);
1552 1553
}

1554
void vm_state_notify(int running, RunState state)
1555
{
1556
    VMChangeStateEntry *e, *next;
1557

1558
    trace_vm_state_notify(running, state);
1559

1560
    QLIST_FOREACH_SAFE(e, &vm_change_state_head, entries, next) {
1561
        e->cb(e->opaque, running, state);
1562 1563 1564
    }
}

1565 1566 1567
static ShutdownCause reset_requested;
static ShutdownCause shutdown_requested;
static int shutdown_signal;
1568
static pid_t shutdown_pid;
B
bellard 已提交
1569
static int powerdown_requested;
1570
static int debug_requested;
1571
static int suspend_requested;
1572
static bool preconfig_exit_requested = true;
L
Liu, Jinsong 已提交
1573
static WakeupReason wakeup_reason;
1574 1575
static NotifierList powerdown_notifiers =
    NOTIFIER_LIST_INITIALIZER(powerdown_notifiers);
1576 1577 1578 1579
static NotifierList suspend_notifiers =
    NOTIFIER_LIST_INITIALIZER(suspend_notifiers);
static NotifierList wakeup_notifiers =
    NOTIFIER_LIST_INITIALIZER(wakeup_notifiers);
L
Liu, Jinsong 已提交
1580
static uint32_t wakeup_reason_mask = ~(1 << QEMU_WAKEUP_REASON_NONE);
1581

1582
ShutdownCause qemu_shutdown_requested_get(void)
1583 1584 1585 1586
{
    return shutdown_requested;
}

1587
ShutdownCause qemu_reset_requested_get(void)
1588 1589 1590 1591
{
    return reset_requested;
}

B
Blue Swirl 已提交
1592
static int qemu_shutdown_requested(void)
A
aurel32 已提交
1593
{
1594
    return atomic_xchg(&shutdown_requested, SHUTDOWN_CAUSE_NONE);
A
aurel32 已提交
1595 1596
}

B
Blue Swirl 已提交
1597
static void qemu_kill_report(void)
1598
{
1599
    if (!qtest_driver() && shutdown_signal) {
1600 1601 1602 1603
        if (shutdown_pid == 0) {
            /* This happens for eg ^C at the terminal, so it's worth
             * avoiding printing an odd message in that case.
             */
1604
            error_report("terminating on signal %d", shutdown_signal);
1605
        } else {
1606 1607 1608 1609 1610 1611
            char *shutdown_cmd = qemu_get_pid_name(shutdown_pid);

            error_report("terminating on signal %d from pid " FMT_pid " (%s)",
                         shutdown_signal, shutdown_pid,
                         shutdown_cmd ? shutdown_cmd : "<unknown process>");
            g_free(shutdown_cmd);
1612
        }
1613
        shutdown_signal = 0;
1614 1615 1616
    }
}

1617
static ShutdownCause qemu_reset_requested(void)
A
aurel32 已提交
1618
{
1619 1620
    ShutdownCause r = reset_requested;

P
Pavel Dovgalyuk 已提交
1621
    if (r && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) {
1622
        reset_requested = SHUTDOWN_CAUSE_NONE;
P
Pavel Dovgalyuk 已提交
1623 1624
        return r;
    }
1625
    return SHUTDOWN_CAUSE_NONE;
A
aurel32 已提交
1626 1627
}

1628 1629 1630
static int qemu_suspend_requested(void)
{
    int r = suspend_requested;
P
Pavel Dovgalyuk 已提交
1631 1632 1633 1634 1635
    if (r && replay_checkpoint(CHECKPOINT_SUSPEND_REQUESTED)) {
        suspend_requested = 0;
        return r;
    }
    return false;
1636 1637
}

L
Liu, Jinsong 已提交
1638
static WakeupReason qemu_wakeup_requested(void)
1639
{
L
Liu, Jinsong 已提交
1640
    return wakeup_reason;
1641 1642
}

B
Blue Swirl 已提交
1643
static int qemu_powerdown_requested(void)
A
aurel32 已提交
1644 1645 1646 1647 1648 1649
{
    int r = powerdown_requested;
    powerdown_requested = 0;
    return r;
}

1650 1651 1652 1653 1654 1655 1656
static int qemu_debug_requested(void)
{
    int r = debug_requested;
    debug_requested = 0;
    return r;
}

1657 1658 1659 1660 1661
void qemu_exit_preconfig_request(void)
{
    preconfig_exit_requested = true;
}

1662 1663 1664 1665
/*
 * Reset the VM. Issue an event unless @reason is SHUTDOWN_CAUSE_NONE.
 */
void qemu_system_reset(ShutdownCause reason)
1666
{
1667 1668 1669 1670
    MachineClass *mc;

    mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;

1671 1672
    cpu_synchronize_all_states();

1673 1674
    if (mc && mc->reset) {
        mc->reset();
1675 1676 1677
    } else {
        qemu_devices_reset();
    }
1678
    if (reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) {
1679
        qapi_event_send_reset(shutdown_caused_by_guest(reason), reason);
J
Jan Kiszka 已提交
1680
    }
1681
    cpu_synchronize_all_post_reset();
1682 1683
}

1684
void qemu_system_guest_panicked(GuestPanicInformation *info)
1685
{
1686
    qemu_log_mask(LOG_GUEST_ERROR, "Guest crashed");
1687

1688 1689 1690
    if (current_cpu) {
        current_cpu->crash_occurred = true;
    }
1691
    qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE,
1692
                                   !!info, info);
1693
    vm_stop(RUN_STATE_GUEST_PANICKED);
1694 1695
    if (!no_shutdown) {
        qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF,
1696
                                       !!info, info);
1697
        qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC);
1698
    }
1699 1700

    if (info) {
1701
        if (info->type == GUEST_PANIC_INFORMATION_TYPE_HYPER_V) {
1702
            qemu_log_mask(LOG_GUEST_ERROR, "\nHV crash parameters: (%#"PRIx64
1703
                          " %#"PRIx64" %#"PRIx64" %#"PRIx64" %#"PRIx64")\n",
1704 1705 1706 1707 1708
                          info->u.hyper_v.arg1,
                          info->u.hyper_v.arg2,
                          info->u.hyper_v.arg3,
                          info->u.hyper_v.arg4,
                          info->u.hyper_v.arg5);
1709 1710 1711 1712 1713 1714 1715
        } else if (info->type == GUEST_PANIC_INFORMATION_TYPE_S390) {
            qemu_log_mask(LOG_GUEST_ERROR, " on cpu %d: %s\n"
                          "PSW: 0x%016" PRIx64 " 0x%016" PRIx64"\n",
                          info->u.s390.core,
                          S390CrashReason_str(info->u.s390.reason),
                          info->u.s390.psw_mask,
                          info->u.s390.psw_addr);
1716
        }
1717 1718
        qapi_free_GuestPanicInformation(info);
    }
1719 1720
}

1721
void qemu_system_reset_request(ShutdownCause reason)
1722
{
1723
    if (no_reboot && reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) {
1724
        shutdown_requested = reason;
B
bellard 已提交
1725
    } else {
1726
        reset_requested = reason;
B
bellard 已提交
1727
    }
1728
    cpu_stop_current();
1729
    qemu_notify_event();
1730 1731
}

1732 1733 1734 1735
static void qemu_system_suspend(void)
{
    pause_all_vcpus();
    notifier_list_notify(&suspend_notifiers, NULL);
1736
    runstate_set(RUN_STATE_SUSPENDED);
1737
    qapi_event_send_suspend();
1738 1739 1740 1741
}

void qemu_system_suspend_request(void)
{
1742
    if (runstate_check(RUN_STATE_SUSPENDED)) {
1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754
        return;
    }
    suspend_requested = 1;
    cpu_stop_current();
    qemu_notify_event();
}

void qemu_register_suspend_notifier(Notifier *notifier)
{
    notifier_list_add(&suspend_notifiers, notifier);
}

1755
void qemu_system_wakeup_request(WakeupReason reason, Error **errp)
1756
{
1757 1758
    trace_system_wakeup_request(reason);

1759
    if (!runstate_check(RUN_STATE_SUSPENDED)) {
1760 1761
        error_setg(errp,
                   "Unable to wake up: guest is not in suspended state");
1762 1763 1764 1765 1766
        return;
    }
    if (!(wakeup_reason_mask & (1 << reason))) {
        return;
    }
1767
    runstate_set(RUN_STATE_RUNNING);
L
Liu, Jinsong 已提交
1768
    wakeup_reason = reason;
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785
    qemu_notify_event();
}

void qemu_system_wakeup_enable(WakeupReason reason, bool enabled)
{
    if (enabled) {
        wakeup_reason_mask |= (1 << reason);
    } else {
        wakeup_reason_mask &= ~(1 << reason);
    }
}

void qemu_register_wakeup_notifier(Notifier *notifier)
{
    notifier_list_add(&wakeup_notifiers, notifier);
}

1786 1787 1788 1789 1790
void qemu_register_wakeup_support(void)
{
    wakeup_suspend_enabled = true;
}

1791
bool qemu_wakeup_suspend_enabled(void)
1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803
{
    return wakeup_suspend_enabled;
}

CurrentMachineParams *qmp_query_current_machine(Error **errp)
{
    CurrentMachineParams *params = g_malloc0(sizeof(*params));
    params->wakeup_suspend_support = qemu_wakeup_suspend_enabled();

    return params;
}

1804 1805 1806 1807
void qemu_system_killed(int signal, pid_t pid)
{
    shutdown_signal = signal;
    shutdown_pid = pid;
1808
    no_shutdown = 0;
P
Pavel Dovgalyuk 已提交
1809 1810 1811 1812

    /* Cannot call qemu_system_shutdown_request directly because
     * we are in a signal handler.
     */
1813
    shutdown_requested = SHUTDOWN_CAUSE_HOST_SIGNAL;
P
Pavel Dovgalyuk 已提交
1814
    qemu_notify_event();
1815 1816
}

1817
void qemu_system_shutdown_request(ShutdownCause reason)
1818
{
1819 1820 1821
    trace_qemu_system_shutdown_request(reason);
    replay_shutdown_request(reason);
    shutdown_requested = reason;
1822
    qemu_notify_event();
1823 1824
}

1825 1826
static void qemu_system_powerdown(void)
{
1827
    qapi_event_send_powerdown();
1828 1829 1830
    notifier_list_notify(&powerdown_notifiers, NULL);
}

B
bellard 已提交
1831 1832
void qemu_system_powerdown_request(void)
{
1833
    trace_qemu_system_powerdown_request();
B
bellard 已提交
1834
    powerdown_requested = 1;
1835 1836 1837
    qemu_notify_event();
}

1838 1839 1840 1841 1842
void qemu_register_powerdown_notifier(Notifier *notifier)
{
    notifier_list_add(&powerdown_notifiers, notifier);
}

1843 1844 1845
void qemu_system_debug_request(void)
{
    debug_requested = 1;
1846
    qemu_notify_event();
1847 1848
}

1849 1850 1851
static bool main_loop_should_exit(void)
{
    RunState r;
1852 1853
    ShutdownCause request;

1854 1855 1856 1857 1858 1859 1860
    if (preconfig_exit_requested) {
        if (runstate_check(RUN_STATE_PRECONFIG)) {
            runstate_set(RUN_STATE_PRELAUNCH);
        }
        preconfig_exit_requested = false;
        return true;
    }
1861 1862 1863
    if (qemu_debug_requested()) {
        vm_stop(RUN_STATE_DEBUG);
    }
1864 1865 1866
    if (qemu_suspend_requested()) {
        qemu_system_suspend();
    }
1867 1868
    request = qemu_shutdown_requested();
    if (request) {
1869
        qemu_kill_report();
1870
        qapi_event_send_shutdown(shutdown_caused_by_guest(request), request);
1871 1872 1873 1874 1875 1876
        if (no_shutdown) {
            vm_stop(RUN_STATE_SHUTDOWN);
        } else {
            return true;
        }
    }
1877 1878
    request = qemu_reset_requested();
    if (request) {
1879
        pause_all_vcpus();
1880
        qemu_system_reset(request);
1881
        resume_all_vcpus();
1882 1883 1884
        if (!runstate_check(RUN_STATE_RUNNING) &&
                !runstate_check(RUN_STATE_INMIGRATE)) {
            runstate_set(RUN_STATE_PRELAUNCH);
1885 1886
        }
    }
1887 1888
    if (qemu_wakeup_requested()) {
        pause_all_vcpus();
1889
        qemu_system_reset(SHUTDOWN_CAUSE_NONE);
L
Liu, Jinsong 已提交
1890 1891
        notifier_list_notify(&wakeup_notifiers, &wakeup_reason);
        wakeup_reason = QEMU_WAKEUP_REASON_NONE;
1892
        resume_all_vcpus();
1893
        qapi_event_send_wakeup();
1894
    }
1895
    if (qemu_powerdown_requested()) {
1896
        qemu_system_powerdown();
1897 1898 1899 1900 1901 1902 1903
    }
    if (qemu_vmstop_requested(&r)) {
        vm_stop(r);
    }
    return false;
}

1904 1905
static void main_loop(void)
{
1906 1907 1908
#ifdef CONFIG_PROFILER
    int64_t ti;
#endif
1909
    while (!main_loop_should_exit()) {
1910
#ifdef CONFIG_PROFILER
J
Jan Kiszka 已提交
1911
        ti = profile_getclock();
1912
#endif
1913
        main_loop_wait(false);
1914
#ifdef CONFIG_PROFILER
J
Jan Kiszka 已提交
1915
        dev_time += profile_getclock() - ti;
1916
#endif
1917
    }
B
bellard 已提交
1918 1919
}

P
pbrook 已提交
1920 1921
static void version(void)
{
1922
    printf("QEMU emulator version " QEMU_FULL_VERSION "\n"
1923
           QEMU_COPYRIGHT "\n");
P
pbrook 已提交
1924 1925
}

1926
static void help(int exitcode)
1927
{
1928 1929 1930 1931 1932
    version();
    printf("usage: %s [options] [disk_image]\n\n"
           "'disk_image' is a raw hard disk image for IDE hard disk 0\n\n",
            error_get_progname());

1933 1934
#define QEMU_OPTIONS_GENERATE_HELP
#include "qemu-options-wrapper.h"
1935 1936

    printf("\nDuring emulation, the following keys are useful:\n"
1937 1938 1939 1940
           "ctrl-alt-f      toggle full screen\n"
           "ctrl-alt-n      switch to virtual console 'n'\n"
           "ctrl-alt        toggle mouse and keyboard grab\n"
           "\n"
1941 1942 1943
           "When using -nographic, press 'ctrl-a h' to get some help.\n"
           "\n"
           QEMU_HELP_BOTTOM "\n");
1944

1945
    exit(exitcode);
1946 1947
}

1948 1949 1950 1951 1952 1953
#define HAS_ARG 0x0001

typedef struct QEMUOption {
    const char *name;
    int flags;
    int index;
1954
    uint32_t arch_mask;
1955 1956
} QEMUOption;

B
blueswir1 已提交
1957
static const QEMUOption qemu_options[] = {
1958
    { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
1959 1960
#define QEMU_OPTIONS_GENERATE_OPTIONS
#include "qemu-options-wrapper.h"
1961
    { NULL },
B
bellard 已提交
1962
};
B
Blue Swirl 已提交
1963

1964 1965 1966
typedef struct VGAInterfaceInfo {
    const char *opt_name;    /* option name */
    const char *name;        /* human-readable name */
1967 1968 1969
    /* Class names indicating that support is available.
     * If no class is specified, the interface is always available */
    const char *class_names[2];
1970 1971 1972 1973 1974 1975 1976 1977 1978
} VGAInterfaceInfo;

static VGAInterfaceInfo vga_interfaces[VGA_TYPE_MAX] = {
    [VGA_NONE] = {
        .opt_name = "none",
    },
    [VGA_STD] = {
        .opt_name = "std",
        .name = "standard VGA",
1979
        .class_names = { "VGA", "isa-vga" },
1980 1981 1982 1983
    },
    [VGA_CIRRUS] = {
        .opt_name = "cirrus",
        .name = "Cirrus VGA",
1984
        .class_names = { "cirrus-vga", "isa-cirrus-vga" },
1985 1986 1987 1988
    },
    [VGA_VMWARE] = {
        .opt_name = "vmware",
        .name = "VMWare SVGA",
1989
        .class_names = { "vmware-svga" },
1990 1991 1992 1993
    },
    [VGA_VIRTIO] = {
        .opt_name = "virtio",
        .name = "Virtio VGA",
1994
        .class_names = { "virtio-vga" },
1995 1996 1997 1998
    },
    [VGA_QXL] = {
        .opt_name = "qxl",
        .name = "QXL VGA",
1999
        .class_names = { "qxl-vga" },
2000 2001 2002 2003
    },
    [VGA_TCX] = {
        .opt_name = "tcx",
        .name = "TCX framebuffer",
2004
        .class_names = { "SUNW,tcx" },
2005 2006 2007 2008
    },
    [VGA_CG3] = {
        .opt_name = "cg3",
        .name = "CG3 framebuffer",
2009
        .class_names = { "cgthree" },
2010 2011 2012 2013 2014 2015
    },
    [VGA_XENFB] = {
        .opt_name = "xenfb",
    },
};

2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
static bool vga_interface_available(VGAInterfaceType t)
{
    VGAInterfaceInfo *ti = &vga_interfaces[t];

    assert(t < VGA_TYPE_MAX);
    return !ti->class_names[0] ||
           object_class_by_name(ti->class_names[0]) ||
           object_class_by_name(ti->class_names[1]);
}

2026
static void select_vgahw(const char *p)
2027 2028
{
    const char *opts;
2029
    int t;
2030

2031
    assert(vga_interface_type == VGA_NONE);
2032 2033 2034
    for (t = 0; t < VGA_TYPE_MAX; t++) {
        VGAInterfaceInfo *ti = &vga_interfaces[t];
        if (ti->opt_name && strstart(p, ti->opt_name, &opts)) {
2035
            if (!vga_interface_available(t)) {
2036 2037 2038 2039 2040
                error_report("%s not available", ti->name);
                exit(1);
            }
            vga_interface_type = t;
            break;
2041
        }
2042 2043
    }
    if (t == VGA_TYPE_MAX) {
2044
    invalid_vga:
2045
        error_report("unknown vga type: %s", p);
2046 2047
        exit(1);
    }
2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060
    while (*opts) {
        const char *nextopt;

        if (strstart(opts, ",retrace=", &nextopt)) {
            opts = nextopt;
            if (strstart(opts, "dumb", &nextopt))
                vga_retrace_method = VGA_RETRACE_DUMB;
            else if (strstart(opts, "precise", &nextopt))
                vga_retrace_method = VGA_RETRACE_PRECISE;
            else goto invalid_vga;
        } else goto invalid_vga;
        opts = nextopt;
    }
2061 2062
}

2063 2064 2065 2066 2067
static void parse_display_qapi(const char *optarg)
{
    DisplayOptions *opts;
    Visitor *v;

2068
    v = qobject_input_visitor_new_str(optarg, "type", &error_fatal);
2069 2070 2071 2072 2073 2074 2075 2076

    visit_type_DisplayOptions(v, NULL, &opts, &error_fatal);
    QAPI_CLONE_MEMBERS(DisplayOptions, &dpy, opts);

    qapi_free_DisplayOptions(opts);
    visit_free(v);
}

2077 2078 2079 2080 2081
DisplayOptions *qmp_query_display_options(Error **errp)
{
    return QAPI_CLONE(DisplayOptions, &dpy);
}

2082
static void parse_display(const char *p)
2083 2084 2085 2086
{
    const char *opts;

    if (strstart(p, "sdl", &opts)) {
2087 2088 2089 2090 2091 2092 2093 2094 2095 2096
        /*
         * sdl DisplayType needs hand-crafted parser instead of
         * parse_display_qapi() due to some options not in
         * DisplayOptions, specifically:
         *   - frame
         *     Already deprecated.
         *   - ctrl_grab + alt_grab
         *     Not clear yet what happens to them long-term.  Should
         *     replaced by something better or deprecated and dropped.
         */
G
Gerd Hoffmann 已提交
2097
        dpy.type = DISPLAY_TYPE_SDL;
2098 2099 2100 2101
        while (*opts) {
            const char *nextopt;

            if (strstart(opts, ",frame=", &nextopt)) {
G
Gerd Hoffmann 已提交
2102 2103
                g_printerr("The frame= sdl option is deprecated, and will be\n"
                           "removed in a future release.\n");
2104 2105 2106 2107 2108 2109
                opts = nextopt;
                if (strstart(opts, "on", &nextopt)) {
                    no_frame = 0;
                } else if (strstart(opts, "off", &nextopt)) {
                    no_frame = 1;
                } else {
2110
                    goto invalid_sdl_args;
2111 2112 2113 2114 2115 2116 2117 2118
                }
            } else if (strstart(opts, ",alt_grab=", &nextopt)) {
                opts = nextopt;
                if (strstart(opts, "on", &nextopt)) {
                    alt_grab = 1;
                } else if (strstart(opts, "off", &nextopt)) {
                    alt_grab = 0;
                } else {
2119
                    goto invalid_sdl_args;
2120 2121 2122 2123 2124 2125 2126 2127
                }
            } else if (strstart(opts, ",ctrl_grab=", &nextopt)) {
                opts = nextopt;
                if (strstart(opts, "on", &nextopt)) {
                    ctrl_grab = 1;
                } else if (strstart(opts, "off", &nextopt)) {
                    ctrl_grab = 0;
                } else {
2128
                    goto invalid_sdl_args;
2129 2130 2131
                }
            } else if (strstart(opts, ",window_close=", &nextopt)) {
                opts = nextopt;
G
Gerd Hoffmann 已提交
2132
                dpy.has_window_close = true;
2133
                if (strstart(opts, "on", &nextopt)) {
G
Gerd Hoffmann 已提交
2134
                    dpy.window_close = true;
2135
                } else if (strstart(opts, "off", &nextopt)) {
G
Gerd Hoffmann 已提交
2136
                    dpy.window_close = false;
2137
                } else {
2138
                    goto invalid_sdl_args;
2139
                }
2140 2141
            } else if (strstart(opts, ",gl=", &nextopt)) {
                opts = nextopt;
G
Gerd Hoffmann 已提交
2142
                dpy.has_gl = true;
2143
                if (strstart(opts, "on", &nextopt)) {
2144
                    dpy.gl = DISPLAYGL_MODE_ON;
2145 2146 2147 2148
                } else if (strstart(opts, "core", &nextopt)) {
                    dpy.gl = DISPLAYGL_MODE_CORE;
                } else if (strstart(opts, "es", &nextopt)) {
                    dpy.gl = DISPLAYGL_MODE_ES;
2149
                } else if (strstart(opts, "off", &nextopt)) {
2150
                    dpy.gl = DISPLAYGL_MODE_OFF;
2151 2152 2153
                } else {
                    goto invalid_sdl_args;
                }
2154
            } else {
2155
            invalid_sdl_args:
2156
                error_report("invalid SDL option string");
2157
                exit(1);
2158 2159 2160
            }
            opts = nextopt;
        }
2161
    } else if (strstart(p, "vnc", &opts)) {
2162 2163 2164 2165
        /*
         * vnc isn't a (local) DisplayType but a protocol for remote
         * display access.
         */
2166
        if (*opts == '=') {
2167
            vnc_parse(opts + 1, &error_fatal);
2168
        } else {
2169
            error_report("VNC requires a display argument vnc=<display>");
2170 2171
            exit(1);
        }
2172
    } else {
2173
        parse_display_qapi(p);
2174 2175 2176
    }
}

P
Paul Brook 已提交
2177 2178
char *qemu_find_file(int type, const char *name)
{
2179
    int i;
P
Paul Brook 已提交
2180 2181 2182
    const char *subdir;
    char *buf;

2183 2184
    /* Try the name as a straight path first */
    if (access(name, R_OK) == 0) {
2185
        trace_load_file(name, name);
2186
        return g_strdup(name);
P
Paul Brook 已提交
2187
    }
2188

P
Paul Brook 已提交
2189 2190 2191 2192 2193 2194 2195 2196 2197 2198
    switch (type) {
    case QEMU_FILE_TYPE_BIOS:
        subdir = "";
        break;
    case QEMU_FILE_TYPE_KEYMAP:
        subdir = "keymaps/";
        break;
    default:
        abort();
    }
2199 2200 2201 2202 2203 2204 2205

    for (i = 0; i < data_dir_idx; i++) {
        buf = g_strdup_printf("%s/%s%s", data_dir[i], subdir, name);
        if (access(buf, R_OK) == 0) {
            trace_load_file(name, buf);
            return buf;
        }
2206
        g_free(buf);
P
Paul Brook 已提交
2207
    }
2208
    return NULL;
P
Paul Brook 已提交
2209 2210
}

G
Gerd Hoffmann 已提交
2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
static void qemu_add_data_dir(const char *path)
{
    int i;

    if (path == NULL) {
        return;
    }
    if (data_dir_idx == ARRAY_SIZE(data_dir)) {
        return;
    }
    for (i = 0; i < data_dir_idx; i++) {
        if (strcmp(data_dir[i], path) == 0) {
            return; /* duplicate */
        }
    }
2226
    data_dir[data_dir_idx++] = g_strdup(path);
G
Gerd Hoffmann 已提交
2227 2228
}

2229 2230 2231 2232 2233
static inline bool nonempty_str(const char *str)
{
    return str && *str;
}

2234 2235 2236 2237
static int parse_fw_cfg(void *opaque, QemuOpts *opts, Error **errp)
{
    gchar *buf;
    size_t size;
2238
    const char *name, *file, *str;
2239
    FWCfgState *fw_cfg = (FWCfgState *) opaque;
2240

2241
    if (fw_cfg == NULL) {
2242
        error_setg(errp, "fw_cfg device not available");
2243 2244 2245 2246
        return -1;
    }
    name = qemu_opt_get(opts, "name");
    file = qemu_opt_get(opts, "file");
2247 2248 2249 2250
    str = qemu_opt_get(opts, "string");

    /* we need name and either a file or the content string */
    if (!(nonempty_str(name) && (nonempty_str(file) || nonempty_str(str)))) {
2251
        error_setg(errp, "invalid argument(s)");
2252 2253 2254
        return -1;
    }
    if (nonempty_str(file) && nonempty_str(str)) {
2255
        error_setg(errp, "file and string are mutually exclusive");
2256 2257 2258
        return -1;
    }
    if (strlen(name) > FW_CFG_MAX_FILE_PATH - 1) {
2259 2260
        error_setg(errp, "name too long (max. %d char)",
                   FW_CFG_MAX_FILE_PATH - 1);
2261 2262 2263
        return -1;
    }
    if (strncmp(name, "opt/", 4) != 0) {
2264 2265
        warn_report("externally provided fw_cfg item names "
                    "should be prefixed with \"opt/\"");
2266
    }
2267 2268 2269 2270
    if (nonempty_str(str)) {
        size = strlen(str); /* NUL terminator NOT included in fw_cfg blob */
        buf = g_memdup(str, size);
    } else {
2271 2272 2273 2274
        GError *err = NULL;
        if (!g_file_get_contents(file, &buf, &size, &err)) {
            error_setg(errp, "can't load %s: %s", file, err->message);
            g_error_free(err);
2275 2276
            return -1;
        }
2277
    }
2278 2279 2280 2281
    /* For legacy, keep user files in a specific global order. */
    fw_cfg_set_order_override(fw_cfg, FW_CFG_ORDER_OVERRIDE_USER);
    fw_cfg_add_file(fw_cfg, name, buf, size);
    fw_cfg_reset_order_override(fw_cfg);
2282 2283 2284
    return 0;
}

2285
static int device_help_func(void *opaque, QemuOpts *opts, Error **errp)
2286 2287 2288 2289
{
    return qdev_device_help(opts);
}

2290
static int device_init_func(void *opaque, QemuOpts *opts, Error **errp)
2291 2292 2293
{
    DeviceState *dev;

2294
    dev = qdev_device_add(opts, errp);
2295
    if (!dev) {
2296
        return -1;
2297
    }
2298
    object_unref(OBJECT(dev));
2299 2300 2301
    return 0;
}

2302
static int chardev_init_func(void *opaque, QemuOpts *opts, Error **errp)
2303
{
2304
    Error *local_err = NULL;
2305

2306 2307
    if (!qemu_chr_new_from_opts(opts, &local_err)) {
        if (local_err) {
2308
            error_propagate(errp, local_err);
2309 2310 2311
            return -1;
        }
        exit(0);
2312
    }
2313 2314 2315
    return 0;
}

2316
#ifdef CONFIG_VIRTFS
2317
static int fsdev_init_func(void *opaque, QemuOpts *opts, Error **errp)
2318
{
2319
    return qemu_fsdev_add(opts, errp);
2320 2321 2322
}
#endif

2323
static int mon_init_func(void *opaque, QemuOpts *opts, Error **errp)
2324
{
2325
    Chardev *chr;
2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338
    const char *chardev;
    const char *mode;
    int flags;

    mode = qemu_opt_get(opts, "mode");
    if (mode == NULL) {
        mode = "readline";
    }
    if (strcmp(mode, "readline") == 0) {
        flags = MONITOR_USE_READLINE;
    } else if (strcmp(mode, "control") == 0) {
        flags = MONITOR_USE_CONTROL;
    } else {
2339 2340
        error_setg(errp, "unknown monitor mode \"%s\"", mode);
        return -1;
2341 2342
    }

2343 2344 2345
    if (qemu_opt_get_bool(opts, "pretty", 0))
        flags |= MONITOR_USE_PRETTY;

2346
    chardev = qemu_opt_get(opts, "chardev");
2347 2348 2349 2350
    if (!chardev) {
        error_report("chardev is required");
        exit(1);
    }
2351 2352
    chr = qemu_chr_find(chardev);
    if (chr == NULL) {
2353 2354
        error_setg(errp, "chardev \"%s\" not found", chardev);
        return -1;
2355 2356 2357 2358 2359 2360
    }

    monitor_init(chr, flags);
    return 0;
}

M
Max Reitz 已提交
2361
static void monitor_parse(const char *optarg, const char *mode, bool pretty)
2362 2363 2364 2365 2366 2367 2368 2369 2370
{
    static int monitor_device_index = 0;
    QemuOpts *opts;
    const char *p;
    char label[32];

    if (strstart(optarg, "chardev:", &p)) {
        snprintf(label, sizeof(label), "%s", p);
    } else {
2371 2372
        snprintf(label, sizeof(label), "compat_monitor%d",
                 monitor_device_index);
2373
        opts = qemu_chr_parse_compat(label, optarg, true);
2374
        if (!opts) {
2375
            error_report("parse error: %s", optarg);
2376 2377 2378 2379
            exit(1);
        }
    }

2380
    opts = qemu_opts_create(qemu_find_opts("mon"), label, 1, &error_fatal);
2381 2382
    qemu_opt_set(opts, "mode", mode, &error_abort);
    qemu_opt_set(opts, "chardev", label, &error_abort);
2383
    qemu_opt_set_bool(opts, "pretty", pretty, &error_abort);
2384 2385 2386
    monitor_device_index++;
}

2387 2388
struct device_config {
    enum {
2389 2390 2391 2392 2393
        DEV_USB,       /* -usbdevice     */
        DEV_BT,        /* -bt            */
        DEV_SERIAL,    /* -serial        */
        DEV_PARALLEL,  /* -parallel      */
        DEV_VIRTCON,   /* -virtioconsole */
2394
        DEV_DEBUGCON,  /* -debugcon */
2395
        DEV_GDB,       /* -gdb, -s */
2396
        DEV_SCLP,      /* s390 sclp */
2397 2398
    } type;
    const char *cmdline;
2399
    Location loc;
2400
    QTAILQ_ENTRY(device_config) next;
2401
};
B
Blue Swirl 已提交
2402 2403 2404

static QTAILQ_HEAD(, device_config) device_configs =
    QTAILQ_HEAD_INITIALIZER(device_configs);
2405 2406 2407 2408 2409

static void add_device_config(int type, const char *cmdline)
{
    struct device_config *conf;

2410
    conf = g_malloc0(sizeof(*conf));
2411 2412
    conf->type = type;
    conf->cmdline = cmdline;
2413
    loc_save(&conf->loc);
2414
    QTAILQ_INSERT_TAIL(&device_configs, conf, next);
2415 2416 2417 2418 2419 2420 2421
}

static int foreach_device_config(int type, int (*func)(const char *cmdline))
{
    struct device_config *conf;
    int rc;

2422
    QTAILQ_FOREACH(conf, &device_configs, next) {
2423 2424
        if (conf->type != type)
            continue;
2425
        loc_push_restore(&conf->loc);
2426
        rc = func(conf->cmdline);
2427
        loc_pop(&conf->loc);
G
Gonglei 已提交
2428
        if (rc) {
2429
            return rc;
G
Gonglei 已提交
2430
        }
2431 2432 2433 2434
    }
    return 0;
}

2435 2436
static int serial_parse(const char *devname)
{
2437
    int index = num_serial_hds;
2438 2439 2440 2441 2442
    char label[32];

    if (strcmp(devname, "none") == 0)
        return 0;
    snprintf(label, sizeof(label), "serial%d", index);
2443 2444
    serial_hds = g_renew(Chardev *, serial_hds, index + 1);

2445
    serial_hds[index] = qemu_chr_new_mux_mon(label, devname);
2446
    if (!serial_hds[index]) {
2447 2448
        error_report("could not connect serial device"
                     " to character backend '%s'", devname);
2449 2450
        return -1;
    }
2451
    num_serial_hds++;
2452 2453 2454
    return 0;
}

2455 2456 2457
Chardev *serial_hd(int i)
{
    assert(i >= 0);
2458
    if (i < num_serial_hds) {
2459 2460 2461 2462 2463
        return serial_hds[i];
    }
    return NULL;
}

2464 2465 2466 2467 2468
int serial_max_hds(void)
{
    return num_serial_hds;
}

2469 2470 2471 2472 2473 2474 2475 2476
static int parallel_parse(const char *devname)
{
    static int index = 0;
    char label[32];

    if (strcmp(devname, "none") == 0)
        return 0;
    if (index == MAX_PARALLEL_PORTS) {
2477
        error_report("too many parallel ports");
2478 2479 2480
        exit(1);
    }
    snprintf(label, sizeof(label), "parallel%d", index);
2481
    parallel_hds[index] = qemu_chr_new_mux_mon(label, devname);
2482
    if (!parallel_hds[index]) {
2483 2484
        error_report("could not connect parallel device"
                     " to character backend '%s'", devname);
2485 2486 2487 2488 2489 2490
        return -1;
    }
    index++;
    return 0;
}

2491 2492
static int virtcon_parse(const char *devname)
{
2493
    QemuOptsList *device = qemu_find_opts("device");
2494 2495
    static int index = 0;
    char label[32];
2496
    QemuOpts *bus_opts, *dev_opts;
2497 2498 2499 2500

    if (strcmp(devname, "none") == 0)
        return 0;
    if (index == MAX_VIRTIO_CONSOLES) {
2501
        error_report("too many virtio consoles");
2502 2503
        exit(1);
    }
2504

2505
    bus_opts = qemu_opts_create(device, NULL, 0, &error_abort);
2506
    qemu_opt_set(bus_opts, "driver", "virtio-serial", &error_abort);
2507

2508
    dev_opts = qemu_opts_create(device, NULL, 0, &error_abort);
2509
    qemu_opt_set(dev_opts, "driver", "virtconsole", &error_abort);
2510

2511
    snprintf(label, sizeof(label), "virtcon%d", index);
2512
    virtcon_hds[index] = qemu_chr_new_mux_mon(label, devname);
2513
    if (!virtcon_hds[index]) {
2514 2515
        error_report("could not connect virtio console"
                     " to character backend '%s'", devname);
2516 2517
        return -1;
    }
2518
    qemu_opt_set(dev_opts, "chardev", label, &error_abort);
2519

2520 2521 2522 2523
    index++;
    return 0;
}

2524
static int debugcon_parse(const char *devname)
L
Laszlo Ersek 已提交
2525
{
2526 2527
    QemuOpts *opts;

2528
    if (!qemu_chr_new_mux_mon("debugcon", devname)) {
2529
        error_report("invalid character backend '%s'", devname);
2530 2531
        exit(1);
    }
2532
    opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL);
2533
    if (!opts) {
2534
        error_report("already have a debugcon device");
2535 2536
        exit(1);
    }
2537 2538
    qemu_opt_set(opts, "driver", "isa-debugcon", &error_abort);
    qemu_opt_set(opts, "chardev", "debugcon", &error_abort);
2539 2540 2541
    return 0;
}

2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576
static gint machine_class_cmp(gconstpointer a, gconstpointer b)
{
    const MachineClass *mc1 = a, *mc2 = b;
    int res;

    if (mc1->family == NULL) {
        if (mc2->family == NULL) {
            /* Compare standalone machine types against each other; they sort
             * in increasing order.
             */
            return strcmp(object_class_get_name(OBJECT_CLASS(mc1)),
                          object_class_get_name(OBJECT_CLASS(mc2)));
        }

        /* Standalone machine types sort after families. */
        return 1;
    }

    if (mc2->family == NULL) {
        /* Families sort before standalone machine types. */
        return -1;
    }

    /* Families sort between each other alphabetically increasingly. */
    res = strcmp(mc1->family, mc2->family);
    if (res != 0) {
        return res;
    }

    /* Within the same family, machine types sort in decreasing order. */
    return strcmp(object_class_get_name(OBJECT_CLASS(mc2)),
                  object_class_get_name(OBJECT_CLASS(mc1)));
}

 static MachineClass *machine_parse(const char *name)
2577
{
2578
    MachineClass *mc = NULL;
2579
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
2580 2581

    if (name) {
2582
        mc = find_machine(name);
2583
    }
2584
    if (mc) {
2585
        g_slist_free(machines);
2586
        return mc;
2587
    }
2588
    if (name && !is_help_option(name)) {
2589
        error_report("unsupported machine type");
2590
        error_printf("Use -machine help to list supported machines\n");
2591 2592
    } else {
        printf("Supported machines are:\n");
2593
        machines = g_slist_sort(machines, machine_class_cmp);
2594 2595
        for (el = machines; el; el = el->next) {
            MachineClass *mc = el->data;
2596 2597
            if (mc->alias) {
                printf("%-20s %s (alias of %s)\n", mc->alias, mc->desc, mc->name);
2598
            }
2599 2600 2601
            printf("%-20s %s%s%s\n", mc->name, mc->desc,
                   mc->is_default ? " (default)" : "",
                   mc->deprecation_reason ? " (deprecated)" : "");
2602 2603
        }
    }
2604 2605

    g_slist_free(machines);
2606
    exit(!name || !is_help_option(name));
2607 2608
}

G
Gerd Hoffmann 已提交
2609 2610 2611 2612 2613 2614 2615
void qemu_add_exit_notifier(Notifier *notify)
{
    notifier_list_add(&exit_notifiers, notify);
}

void qemu_remove_exit_notifier(Notifier *notify)
{
P
Paolo Bonzini 已提交
2616
    notifier_remove(notify);
G
Gerd Hoffmann 已提交
2617 2618 2619 2620
}

static void qemu_run_exit_notifiers(void)
{
2621
    notifier_list_notify(&exit_notifiers, NULL);
G
Gerd Hoffmann 已提交
2622 2623
}

2624 2625 2626 2627 2628 2629 2630 2631 2632 2633
static const char *pid_file;
static Notifier qemu_unlink_pidfile_notifier;

static void qemu_unlink_pidfile(Notifier *n, void *data)
{
    if (pid_file) {
        unlink(pid_file);
    }
}

P
Peter Xu 已提交
2634
bool machine_init_done;
2635

2636 2637 2638
void qemu_add_machine_init_done_notifier(Notifier *notify)
{
    notifier_list_add(&machine_init_done_notifiers, notify);
2639 2640 2641
    if (machine_init_done) {
        notify->notify(notify, NULL);
    }
2642 2643
}

2644 2645 2646 2647 2648
void qemu_remove_machine_init_done_notifier(Notifier *notify)
{
    notifier_remove(notify);
}

2649 2650
static void qemu_run_machine_init_done_notifiers(void)
{
2651
    machine_init_done = true;
P
Peter Xu 已提交
2652
    notifier_list_notify(&machine_init_done_notifiers, NULL);
2653 2654
}

2655 2656 2657 2658 2659 2660 2661 2662
static const QEMUOption *lookup_opt(int argc, char **argv,
                                    const char **poptarg, int *poptind)
{
    const QEMUOption *popt;
    int optind = *poptind;
    char *r = argv[optind];
    const char *optarg;

2663
    loc_set_cmdline(argv, optind, 1);
2664 2665 2666 2667 2668 2669 2670
    optind++;
    /* Treat --foo the same as -foo.  */
    if (r[1] == '-')
        r++;
    popt = qemu_options;
    for(;;) {
        if (!popt->name) {
2671
            error_report("invalid option");
2672 2673 2674 2675 2676 2677 2678 2679
            exit(1);
        }
        if (!strcmp(popt->name, r + 1))
            break;
        popt++;
    }
    if (popt->flags & HAS_ARG) {
        if (optind >= argc) {
2680
            error_report("requires an argument");
2681 2682 2683
            exit(1);
        }
        optarg = argv[optind++];
2684
        loc_set_cmdline(argv, optind - 2, 2);
2685 2686 2687 2688 2689 2690 2691 2692 2693 2694
    } else {
        optarg = NULL;
    }

    *poptarg = optarg;
    *poptind = optind;

    return popt;
}

2695
static MachineClass *select_machine(void)
2696
{
2697
    MachineClass *machine_class = find_default_machine();
2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708
    const char *optarg;
    QemuOpts *opts;
    Location loc;

    loc_push_none(&loc);

    opts = qemu_get_machine_opts();
    qemu_opts_loc_restore(opts);

    optarg = qemu_opt_get(opts, "type");
    if (optarg) {
2709
        machine_class = machine_parse(optarg);
2710 2711
    }

2712
    if (!machine_class) {
2713 2714 2715 2716 2717 2718
        error_report("No machine specified, and there is no default");
        error_printf("Use -machine help to list supported machines\n");
        exit(1);
    }

    loc_pop(&loc);
2719
    return machine_class;
2720 2721
}

2722 2723 2724
static int machine_set_property(void *opaque,
                                const char *name, const char *value,
                                Error **errp)
2725 2726 2727
{
    Object *obj = OBJECT(opaque);
    Error *local_err = NULL;
2728
    char *p, *qom_name;
2729

2730
    if (strcmp(name, "type") == 0) {
2731 2732 2733
        return 0;
    }

2734
    qom_name = g_strdup(name);
2735 2736 2737
    for (p = qom_name; *p; p++) {
        if (*p == '_') {
            *p = '-';
2738 2739 2740
        }
    }

2741
    object_property_parse(obj, value, qom_name, &local_err);
2742
    g_free(qom_name);
2743 2744

    if (local_err) {
2745
        error_propagate(errp, local_err);
2746 2747 2748 2749 2750 2751
        return -1;
    }

    return 0;
}

2752 2753 2754 2755 2756 2757 2758 2759

/*
 * Initial object creation happens before all other
 * QEMU data types are created. The majority of objects
 * can be created at this point. The rng-egd object
 * cannot be created here, as it depends on the chardev
 * already existing.
 */
2760
static bool object_create_initial(const char *type, QemuOpts *opts)
2761
{
2762 2763
    ObjectClass *klass;

2764 2765 2766 2767 2768 2769 2770
    if (is_help_option(type)) {
        GSList *l, *list;

        printf("List of user creatable objects:\n");
        list = object_class_get_list_sorted(TYPE_USER_CREATABLE, false);
        for (l = list; l != NULL; l = l->next) {
            ObjectClass *oc = OBJECT_CLASS(l->data);
2771
            printf("  %s\n", object_class_get_name(oc));
2772 2773 2774 2775 2776
        }
        g_slist_free(list);
        exit(0);
    }

2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792
    klass = object_class_by_name(type);
    if (klass && qemu_opt_has_help_opt(opts)) {
        ObjectPropertyIterator iter;
        ObjectProperty *prop;
        GPtrArray *array = g_ptr_array_new();
        int i;

        object_class_property_iter_init(&iter, klass);
        while ((prop = object_property_iter_next(&iter))) {
            GString *str;

            if (!prop->set) {
                continue;
            }

            str = g_string_new(NULL);
2793
            g_string_append_printf(str, "  %s=<%s>", prop->name, prop->type);
2794
            if (prop->description) {
2795 2796 2797
                if (str->len < 24) {
                    g_string_append_printf(str, "%*s", 24 - (int)str->len, "");
                }
2798 2799 2800 2801 2802
                g_string_append_printf(str, " - %s", prop->description);
            }
            g_ptr_array_add(array, g_string_free(str, false));
        }
        g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
2803 2804 2805 2806 2807
        if (array->len > 0) {
            printf("%s options:\n", type);
        } else {
            printf("There are no options for %s.\n", type);
        }
2808 2809 2810 2811 2812 2813 2814 2815
        for (i = 0; i < array->len; i++) {
            printf("%s\n", (char *)array->pdata[i]);
        }
        g_ptr_array_set_free_func(array, g_free);
        g_ptr_array_free(array, true);
        exit(0);
    }

2816 2817
    if (g_str_equal(type, "rng-egd") ||
        g_str_has_prefix(type, "pr-manager-")) {
2818 2819
        return false;
    }
2820

2821 2822 2823 2824 2825 2826
#if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
    if (g_str_equal(type, "cryptodev-vhost-user")) {
        return false;
    }
#endif

2827 2828 2829 2830 2831
    /*
     * return false for concrete netfilters since
     * they depend on netdevs already existing
     */
    if (g_str_equal(type, "filter-buffer") ||
2832
        g_str_equal(type, "filter-dump") ||
2833
        g_str_equal(type, "filter-mirror") ||
2834
        g_str_equal(type, "filter-redirector") ||
2835
        g_str_equal(type, "colo-compare") ||
2836 2837
        g_str_equal(type, "filter-rewriter") ||
        g_str_equal(type, "filter-replay")) {
2838 2839 2840
        return false;
    }

2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853
    /* Memory allocation by backends needs to be done
     * after configure_accelerator() (due to the tcg_enabled()
     * checks at memory_region_init_*()).
     *
     * Also, allocation of large amounts of memory may delay
     * chardev initialization for too long, and trigger timeouts
     * on software that waits for a monitor socket to be created
     * (e.g. libvirt).
     */
    if (g_str_has_prefix(type, "memory-backend-")) {
        return false;
    }

2854 2855 2856 2857 2858 2859
    return true;
}


/*
 * The remainder of object creation happens after the
2860
 * creation of chardev, fsdev, net clients and device data types.
2861
 */
2862
static bool object_create_delayed(const char *type, QemuOpts *opts)
2863
{
2864
    return !object_create_initial(type, opts);
2865 2866 2867
}


2868 2869
static void set_memory_options(uint64_t *ram_slots, ram_addr_t *maxram_size,
                               MachineClass *mc)
2870 2871 2872
{
    uint64_t sz;
    const char *mem_str;
2873
    const ram_addr_t default_ram_size = mc->default_ram_size;
2874
    QemuOpts *opts = qemu_find_opts_singleton("memory");
2875 2876 2877 2878
    Location loc;

    loc_push_none(&loc);
    qemu_opts_loc_restore(opts);
2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893

    sz = 0;
    mem_str = qemu_opt_get(opts, "size");
    if (mem_str) {
        if (!*mem_str) {
            error_report("missing 'size' option value");
            exit(EXIT_FAILURE);
        }

        sz = qemu_opt_get_size(opts, "size", ram_size);

        /* Fix up legacy suffix-less format */
        if (g_ascii_isdigit(mem_str[strlen(mem_str) - 1])) {
            uint64_t overflow_check = sz;

2894 2895
            sz *= MiB;
            if (sz / MiB != overflow_check) {
2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914
                error_report("too large 'size' option value");
                exit(EXIT_FAILURE);
            }
        }
    }

    /* backward compatibility behaviour for case "-m 0" */
    if (sz == 0) {
        sz = default_ram_size;
    }

    sz = QEMU_ALIGN_UP(sz, 8192);
    ram_size = sz;
    if (ram_size != sz) {
        error_report("ram size too large");
        exit(EXIT_FAILURE);
    }

    /* store value for the future use */
2915
    qemu_opt_set_number(opts, "size", ram_size, &error_abort);
2916 2917
    *maxram_size = ram_size;

2918
    if (qemu_opt_get(opts, "maxmem")) {
2919 2920 2921
        uint64_t slots;

        sz = qemu_opt_get_size(opts, "maxmem", 0);
2922
        slots = qemu_opt_get_number(opts, "slots", 0);
2923
        if (sz < ram_size) {
2924 2925 2926 2927
            error_report("invalid value of -m option maxmem: "
                         "maximum memory size (0x%" PRIx64 ") must be at least "
                         "the initial memory size (0x" RAM_ADDR_FMT ")",
                         sz, ram_size);
2928
            exit(EXIT_FAILURE);
2929
        } else if (slots && sz == ram_size) {
2930 2931 2932 2933
            error_report("invalid value of -m option maxmem: "
                         "memory slots were specified but maximum memory size "
                         "(0x%" PRIx64 ") is equal to the initial memory size "
                         "(0x" RAM_ADDR_FMT ")", sz, ram_size);
2934 2935 2936 2937 2938
            exit(EXIT_FAILURE);
        }

        *maxram_size = sz;
        *ram_slots = slots;
2939 2940
    } else if (qemu_opt_get(opts, "slots")) {
        error_report("invalid -m option value: missing 'maxmem' option");
2941 2942
        exit(EXIT_FAILURE);
    }
2943 2944

    loc_pop(&loc);
2945 2946
}

2947 2948 2949 2950 2951 2952 2953 2954 2955
static int global_init_func(void *opaque, QemuOpts *opts, Error **errp)
{
    GlobalProperty *g;

    g = g_malloc0(sizeof(*g));
    g->driver   = qemu_opt_get(opts, "driver");
    g->property = qemu_opt_get(opts, "property");
    g->value    = qemu_opt_get(opts, "value");
    g->user_provided = true;
2956
    g->errp = &error_fatal;
2957 2958 2959 2960
    qdev_prop_register_global(g);
    return 0;
}

2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972
static int qemu_read_default_config_file(void)
{
    int ret;

    ret = qemu_read_config_file(CONFIG_QEMU_CONFDIR "/qemu.conf");
    if (ret < 0 && ret != -ENOENT) {
        return ret;
    }

    return 0;
}

2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991
static void user_register_global_props(void)
{
    qemu_opts_foreach(qemu_find_opts("global"),
                      global_init_func, NULL, NULL);
}

/*
 * Note: we should see that these properties are actually having a
 * priority: accel < machine < user. This means e.g. when user
 * specifies something in "-global", it'll always be used with highest
 * priority than either machine/accelerator compat properties.
 */
static void register_global_properties(MachineState *ms)
{
    accel_register_compat_props(ms->accelerator);
    machine_register_compat_props(ms);
    user_register_global_props();
}

M
malc 已提交
2992
int main(int argc, char **argv, char **envp)
2993
{
2994
    int i;
2995
    int snapshot, linux_boot;
2996
    const char *initrd_filename;
2997
    const char *kernel_filename, *kernel_cmdline;
2998 2999
    const char *boot_order = NULL;
    const char *boot_once = NULL;
3000
    DisplayState *ds;
3001
    QemuOpts *opts, *machine_opts;
3002
    QemuOpts *icount_opts = NULL, *accel_opts = NULL;
3003
    QemuOptsList *olist;
3004
    int optind;
3005
    const char *optarg;
3006
    const char *loadvm = NULL;
3007
    MachineClass *machine_class;
3008
    const char *cpu_model;
3009
    const char *vga_model = NULL;
3010 3011
    const char *qtest_chrdev = NULL;
    const char *qtest_log = NULL;
3012
    const char *incoming = NULL;
3013
    bool userconfig = true;
3014
    bool nographic = false;
3015
    int display_remote = 0;
3016 3017
    const char *log_mask = NULL;
    const char *log_file = NULL;
3018
    char *trace_file = NULL;
3019
    ram_addr_t maxram_size;
3020
    uint64_t ram_slots = 0;
3021
    FILE *vmstate_dump_file = NULL;
3022
    Error *main_loop_err = NULL;
3023
    Error *err = NULL;
3024
    bool list_data_dirs = false;
3025
    char *dir, **dirs;
3026 3027 3028 3029 3030 3031 3032
    typedef struct BlockdevOptions_queue {
        BlockdevOptions *bdo;
        Location loc;
        QSIMPLEQ_ENTRY(BlockdevOptions_queue) entry;
    } BlockdevOptions_queue;
    QSIMPLEQ_HEAD(, BlockdevOptions_queue) bdo_queue
        = QSIMPLEQ_HEAD_INITIALIZER(bdo_queue);
3033

3034 3035
    module_call_init(MODULE_INIT_TRACE);

3036
    qemu_init_cpu_list();
3037
    qemu_init_cpu_loop();
3038

3039 3040
    qemu_mutex_lock_iothread();

G
Gerd Hoffmann 已提交
3041
    atexit(qemu_run_exit_notifiers);
3042
    error_set_progname(argv[0]);
3043
    qemu_init_exec_dir(argv[0]);
3044

3045 3046
    module_call_init(MODULE_INIT_QOM);

3047
    qemu_add_opts(&qemu_drive_opts);
3048 3049 3050
    qemu_add_drive_opts(&qemu_legacy_drive_opts);
    qemu_add_drive_opts(&qemu_common_drive_opts);
    qemu_add_drive_opts(&qemu_drive_opts);
3051
    qemu_add_drive_opts(&bdrv_runtime_opts);
3052 3053 3054
    qemu_add_opts(&qemu_chardev_opts);
    qemu_add_opts(&qemu_device_opts);
    qemu_add_opts(&qemu_netdev_opts);
3055
    qemu_add_opts(&qemu_nic_opts);
3056 3057 3058 3059 3060 3061 3062
    qemu_add_opts(&qemu_net_opts);
    qemu_add_opts(&qemu_rtc_opts);
    qemu_add_opts(&qemu_global_opts);
    qemu_add_opts(&qemu_mon_opts);
    qemu_add_opts(&qemu_trace_opts);
    qemu_add_opts(&qemu_option_rom_opts);
    qemu_add_opts(&qemu_machine_opts);
3063
    qemu_add_opts(&qemu_accel_opts);
3064
    qemu_add_opts(&qemu_mem_opts);
3065
    qemu_add_opts(&qemu_smp_opts);
3066 3067 3068
    qemu_add_opts(&qemu_boot_opts);
    qemu_add_opts(&qemu_add_fd_opts);
    qemu_add_opts(&qemu_object_opts);
3069
    qemu_add_opts(&qemu_tpmdev_opts);
3070
    qemu_add_opts(&qemu_realtime_opts);
3071
    qemu_add_opts(&qemu_overcommit_opts);
3072
    qemu_add_opts(&qemu_msg_opts);
3073
    qemu_add_opts(&qemu_name_opts);
3074
    qemu_add_opts(&qemu_numa_opts);
3075
    qemu_add_opts(&qemu_icount_opts);
3076
    qemu_add_opts(&qemu_semihosting_config_opts);
3077
    qemu_add_opts(&qemu_fw_cfg_opts);
3078
    module_call_init(MODULE_INIT_OPTS);
3079

3080
    runstate_init();
3081
    postcopy_infrastructure_init();
3082
    monitor_init_globals();
3083

3084
    if (qcrypto_init(&err) < 0) {
3085
        error_reportf_err(err, "cannot initialize crypto: ");
3086 3087
        exit(1);
    }
J
Jan Kiszka 已提交
3088

3089
    QLIST_INIT (&vm_change_state_head);
3090
    os_setup_early_signal_handling();
3091

3092
    cpu_model = NULL;
3093
    snapshot = 0;
3094

B
bellard 已提交
3095
    nb_nics = 0;
3096

3097 3098
    bdrv_init_with_whitelist();

3099
    autostart = 1;
3100

3101 3102 3103 3104 3105
    /* first pass of option parsing */
    optind = 1;
    while (optind < argc) {
        if (argv[optind][0] != '-') {
            /* disk image */
3106
            optind++;
3107 3108 3109 3110 3111
        } else {
            const QEMUOption *popt;

            popt = lookup_opt(argc, argv, &optarg, &optind);
            switch (popt->index) {
3112 3113 3114
            case QEMU_OPTION_nouserconfig:
                userconfig = false;
                break;
3115 3116 3117 3118
            }
        }
    }

3119
    if (userconfig) {
3120
        if (qemu_read_default_config_file() < 0) {
3121
            exit(1);
3122 3123 3124 3125
        }
    }

    /* second pass of option parsing */
3126
    optind = 1;
3127
    for(;;) {
3128
        if (optind >= argc)
3129
            break;
3130
        if (argv[optind][0] != '-') {
3131
            drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
3132 3133 3134
        } else {
            const QEMUOption *popt;

3135
            popt = lookup_opt(argc, argv, &optarg, &optind);
3136
            if (!(popt->arch_mask & arch_type)) {
3137
                error_report("Option not supported for this target");
3138 3139
                exit(1);
            }
3140
            switch(popt->index) {
3141 3142
            case QEMU_OPTION_cpu:
                /* hw initialization will check this */
3143
                cpu_model = optarg;
3144
                break;
3145 3146
            case QEMU_OPTION_hda:
            case QEMU_OPTION_hdb:
3147 3148
            case QEMU_OPTION_hdc:
            case QEMU_OPTION_hdd:
3149 3150
                drive_add(IF_DEFAULT, popt->index - QEMU_OPTION_hda, optarg,
                          HD_OPTS);
B
bellard 已提交
3151
                break;
3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170
            case QEMU_OPTION_blockdev:
                {
                    Visitor *v;
                    BlockdevOptions_queue *bdo;

                    v = qobject_input_visitor_new_str(optarg, "driver", &err);
                    if (!v) {
                        error_report_err(err);
                        exit(1);
                    }

                    bdo = g_new(BlockdevOptions_queue, 1);
                    visit_type_BlockdevOptions(v, NULL, &bdo->bdo,
                                               &error_fatal);
                    visit_free(v);
                    loc_save(&bdo->loc);
                    QSIMPLEQ_INSERT_TAIL(&bdo_queue, bdo, entry);
                    break;
                }
3171
            case QEMU_OPTION_drive:
3172 3173 3174
                if (drive_def(optarg) == NULL) {
                    exit(1);
                }
3175
                break;
G
Gerd Hoffmann 已提交
3176 3177 3178
            case QEMU_OPTION_set:
                if (qemu_set_option(optarg) != 0)
                    exit(1);
3179
                break;
3180 3181 3182
            case QEMU_OPTION_global:
                if (qemu_global_option(optarg) != 0)
                    exit(1);
3183
                break;
3184
            case QEMU_OPTION_mtdblock:
3185
                drive_add(IF_MTD, -1, optarg, MTD_OPTS);
3186
                break;
3187
            case QEMU_OPTION_sd:
3188
                drive_add(IF_SD, -1, optarg, SD_OPTS);
3189
                break;
3190
            case QEMU_OPTION_pflash:
3191
                drive_add(IF_PFLASH, -1, optarg, PFLASH_OPTS);
3192
                break;
3193
            case QEMU_OPTION_snapshot:
3194 3195
                snapshot = 1;
                break;
3196
            case QEMU_OPTION_numa:
3197 3198
                opts = qemu_opts_parse_noisily(qemu_find_opts("numa"),
                                               optarg, true);
3199 3200 3201
                if (!opts) {
                    exit(1);
                }
3202
                break;
3203
            case QEMU_OPTION_display:
3204
                parse_display(optarg);
3205
                break;
3206
            case QEMU_OPTION_nographic:
3207 3208 3209
                olist = qemu_find_opts("machine");
                qemu_opts_parse_noisily(olist, "graphics=off", false);
                nographic = true;
3210
                dpy.type = DISPLAY_TYPE_NONE;
3211
                break;
B
balrog 已提交
3212
            case QEMU_OPTION_curses:
3213
#ifdef CONFIG_CURSES
3214
                dpy.type = DISPLAY_TYPE_CURSES;
3215
#else
3216
                error_report("curses support is disabled");
3217
                exit(1);
B
balrog 已提交
3218
#endif
3219
                break;
3220
            case QEMU_OPTION_portrait:
3221 3222 3223 3224 3225 3226
                graphic_rotate = 90;
                break;
            case QEMU_OPTION_rotate:
                graphic_rotate = strtol(optarg, (char **) &optarg, 10);
                if (graphic_rotate != 0 && graphic_rotate != 90 &&
                    graphic_rotate != 180 && graphic_rotate != 270) {
3227
                    error_report("only 90, 180, 270 deg rotation is available");
3228 3229
                    exit(1);
                }
3230
                break;
3231
            case QEMU_OPTION_kernel:
3232 3233
                qemu_opts_set(qemu_find_opts("machine"), 0, "kernel", optarg,
                              &error_abort);
3234 3235
                break;
            case QEMU_OPTION_initrd:
3236 3237
                qemu_opts_set(qemu_find_opts("machine"), 0, "initrd", optarg,
                              &error_abort);
3238
                break;
3239
            case QEMU_OPTION_append:
3240 3241
                qemu_opts_set(qemu_find_opts("machine"), 0, "append", optarg,
                              &error_abort);
3242
                break;
3243
            case QEMU_OPTION_dtb:
3244 3245
                qemu_opts_set(qemu_find_opts("machine"), 0, "dtb", optarg,
                              &error_abort);
3246
                break;
3247
            case QEMU_OPTION_cdrom:
3248
                drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS);
3249
                break;
3250
            case QEMU_OPTION_boot:
3251 3252
                opts = qemu_opts_parse_noisily(qemu_find_opts("boot-opts"),
                                               optarg, true);
3253 3254
                if (!opts) {
                    exit(1);
3255 3256
                }
                break;
3257 3258
            case QEMU_OPTION_fda:
            case QEMU_OPTION_fdb:
3259 3260
                drive_add(IF_FLOPPY, popt->index - QEMU_OPTION_fda,
                          optarg, FD_OPTS);
3261
                break;
3262 3263 3264
            case QEMU_OPTION_no_fd_bootchk:
                fd_bootchk = 0;
                break;
M
Mark McLoughlin 已提交
3265
            case QEMU_OPTION_netdev:
3266
                default_net = 0;
3267
                if (net_client_parse(qemu_find_opts("netdev"), optarg) == -1) {
M
Mark McLoughlin 已提交
3268 3269 3270
                    exit(1);
                }
                break;
3271 3272 3273 3274 3275 3276
            case QEMU_OPTION_nic:
                default_net = 0;
                if (net_client_parse(qemu_find_opts("nic"), optarg) == -1) {
                    exit(1);
                }
                break;
B
bellard 已提交
3277
            case QEMU_OPTION_net:
3278
                default_net = 0;
3279
                if (net_client_parse(qemu_find_opts("net"), optarg) == -1) {
3280 3281
                    exit(1);
                }
B
bellard 已提交
3282
                break;
3283 3284
#ifdef CONFIG_LIBISCSI
            case QEMU_OPTION_iscsi:
3285 3286
                opts = qemu_opts_parse_noisily(qemu_find_opts("iscsi"),
                                               optarg, false);
3287 3288 3289 3290
                if (!opts) {
                    exit(1);
                }
                break;
B
bellard 已提交
3291
#endif
3292
            case QEMU_OPTION_bt:
3293 3294 3295 3296
                warn_report("The bluetooth subsystem is deprecated and will "
                            "be removed soon. If the bluetooth subsystem is "
                            "still useful for you, please send a mail to "
                            "qemu-devel@nongnu.org with your usecase.");
3297
                add_device_config(DEV_BT, optarg);
3298
                break;
3299 3300 3301 3302 3303 3304 3305
            case QEMU_OPTION_audio_help:
                AUD_help ();
                exit (0);
                break;
            case QEMU_OPTION_soundhw:
                select_soundhw (optarg);
                break;
3306
            case QEMU_OPTION_h:
3307
                help(0);
3308
                break;
P
pbrook 已提交
3309 3310 3311 3312
            case QEMU_OPTION_version:
                version();
                exit(0);
                break;
3313
            case QEMU_OPTION_m:
3314 3315
                opts = qemu_opts_parse_noisily(qemu_find_opts("memory"),
                                               optarg, true);
3316 3317 3318
                if (!opts) {
                    exit(EXIT_FAILURE);
                }
3319
                break;
3320 3321 3322 3323 3324 3325 3326
#ifdef CONFIG_TPM
            case QEMU_OPTION_tpmdev:
                if (tpm_config_parse(qemu_find_opts("tpmdev"), optarg) < 0) {
                    exit(1);
                }
                break;
#endif
3327 3328 3329 3330 3331 3332
            case QEMU_OPTION_mempath:
                mem_path = optarg;
                break;
            case QEMU_OPTION_mem_prealloc:
                mem_prealloc = 1;
                break;
3333
            case QEMU_OPTION_d:
3334 3335 3336 3337
                log_mask = optarg;
                break;
            case QEMU_OPTION_D:
                log_file = optarg;
3338
                break;
3339
            case QEMU_OPTION_DFILTER:
3340
                qemu_set_dfilter_ranges(optarg, &error_fatal);
3341
                break;
3342
            case QEMU_OPTION_s:
3343
                add_device_config(DEV_GDB, "tcp::" DEFAULT_GDBSTUB_PORT);
3344
                break;
3345
            case QEMU_OPTION_gdb:
3346
                add_device_config(DEV_GDB, optarg);
3347 3348
                break;
            case QEMU_OPTION_L:
3349 3350
                if (is_help_option(optarg)) {
                    list_data_dirs = true;
G
Gerd Hoffmann 已提交
3351 3352
                } else {
                    qemu_add_data_dir(optarg);
3353
                }
3354
                break;
3355
            case QEMU_OPTION_bios:
3356 3357
                qemu_opts_set(qemu_find_opts("machine"), 0, "firmware", optarg,
                              &error_abort);
3358
                break;
3359 3360 3361
            case QEMU_OPTION_singlestep:
                singlestep = 1;
                break;
3362
            case QEMU_OPTION_S:
3363
                autostart = 0;
3364
                break;
3365 3366 3367
            case QEMU_OPTION_k:
                keyboard_layout = optarg;
                break;
3368
            case QEMU_OPTION_vga:
B
Blue Swirl 已提交
3369
                vga_model = optarg;
3370
                default_vga = 0;
3371
                break;
3372 3373 3374 3375 3376 3377 3378 3379
            case QEMU_OPTION_g:
                {
                    const char *p;
                    int w, h, depth;
                    p = optarg;
                    w = strtol(p, (char **)&p, 10);
                    if (w <= 0) {
                    graphic_error:
3380
                        error_report("invalid resolution or depth");
3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391
                        exit(1);
                    }
                    if (*p != 'x')
                        goto graphic_error;
                    p++;
                    h = strtol(p, (char **)&p, 10);
                    if (h <= 0)
                        goto graphic_error;
                    if (*p == 'x') {
                        p++;
                        depth = strtol(p, (char **)&p, 10);
3392
                        if (depth != 8 && depth != 15 && depth != 16 &&
3393 3394 3395 3396 3397 3398 3399
                            depth != 24 && depth != 32)
                            goto graphic_error;
                    } else if (*p == '\0') {
                        depth = graphic_depth;
                    } else {
                        goto graphic_error;
                    }
3400

3401 3402 3403 3404 3405
                    graphic_width = w;
                    graphic_height = h;
                    graphic_depth = depth;
                }
                break;
3406 3407 3408 3409 3410 3411 3412 3413
            case QEMU_OPTION_echr:
                {
                    char *r;
                    term_escape_char = strtol(optarg, &r, 0);
                    if (r == optarg)
                        printf("Bad argument to echr\n");
                    break;
                }
B
bellard 已提交
3414
            case QEMU_OPTION_monitor:
3415
                default_monitor = 0;
3416
                if (strncmp(optarg, "none", 4)) {
M
Max Reitz 已提交
3417
                    monitor_parse(optarg, "readline", false);
3418
                }
3419 3420
                break;
            case QEMU_OPTION_qmp:
M
Max Reitz 已提交
3421 3422 3423 3424 3425
                monitor_parse(optarg, "control", false);
                default_monitor = 0;
                break;
            case QEMU_OPTION_qmp_pretty:
                monitor_parse(optarg, "control", true);
3426
                default_monitor = 0;
B
bellard 已提交
3427
                break;
G
Gerd Hoffmann 已提交
3428
            case QEMU_OPTION_mon:
3429 3430
                opts = qemu_opts_parse_noisily(qemu_find_opts("mon"), optarg,
                                               true);
G
Gerd Hoffmann 已提交
3431 3432 3433
                if (!opts) {
                    exit(1);
                }
3434
                default_monitor = 0;
G
Gerd Hoffmann 已提交
3435
                break;
3436
            case QEMU_OPTION_chardev:
3437 3438
                opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
                                               optarg, true);
3439 3440 3441 3442
                if (!opts) {
                    exit(1);
                }
                break;
3443
            case QEMU_OPTION_fsdev:
3444 3445
                olist = qemu_find_opts("fsdev");
                if (!olist) {
3446
                    error_report("fsdev support is disabled");
3447 3448
                    exit(1);
                }
3449
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3450 3451 3452 3453
                if (!opts) {
                    exit(1);
                }
                break;
3454
            case QEMU_OPTION_virtfs: {
3455 3456
                QemuOpts *fsdev;
                QemuOpts *device;
3457
                const char *writeout, *sock_fd, *socket, *path, *security_model;
3458

3459 3460
                olist = qemu_find_opts("virtfs");
                if (!olist) {
3461
                    error_report("virtfs support is disabled");
3462 3463
                    exit(1);
                }
3464
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3465 3466 3467 3468
                if (!opts) {
                    exit(1);
                }

3469
                if (qemu_opt_get(opts, "fsdriver") == NULL ||
3470
                    qemu_opt_get(opts, "mount_tag") == NULL) {
3471
                    error_report("Usage: -virtfs fsdriver,mount_tag=tag");
3472 3473
                    exit(1);
                }
3474
                fsdev = qemu_opts_create(qemu_find_opts("fsdev"),
3475
                                         qemu_opts_id(opts) ?:
3476 3477
                                         qemu_opt_get(opts, "mount_tag"),
                                         1, NULL);
3478
                if (!fsdev) {
3479
                    error_report("duplicate or invalid fsdev id: %s",
3480
                                 qemu_opt_get(opts, "mount_tag"));
3481 3482
                    exit(1);
                }
3483 3484 3485 3486

                writeout = qemu_opt_get(opts, "writeout");
                if (writeout) {
#ifdef CONFIG_SYNC_FILE_RANGE
3487
                    qemu_opt_set(fsdev, "writeout", writeout, &error_abort);
3488
#else
3489 3490
                    error_report("writeout=immediate not supported "
                                 "on this platform");
3491 3492 3493
                    exit(1);
#endif
                }
3494 3495
                qemu_opt_set(fsdev, "fsdriver",
                             qemu_opt_get(opts, "fsdriver"), &error_abort);
3496 3497 3498 3499 3500 3501 3502 3503 3504
                path = qemu_opt_get(opts, "path");
                if (path) {
                    qemu_opt_set(fsdev, "path", path, &error_abort);
                }
                security_model = qemu_opt_get(opts, "security_model");
                if (security_model) {
                    qemu_opt_set(fsdev, "security_model", security_model,
                                 &error_abort);
                }
3505 3506
                socket = qemu_opt_get(opts, "socket");
                if (socket) {
3507
                    qemu_opt_set(fsdev, "socket", socket, &error_abort);
3508
                }
3509 3510
                sock_fd = qemu_opt_get(opts, "sock_fd");
                if (sock_fd) {
3511
                    qemu_opt_set(fsdev, "sock_fd", sock_fd, &error_abort);
3512
                }
3513

3514
                qemu_opt_set_bool(fsdev, "readonly",
3515 3516
                                  qemu_opt_get_bool(opts, "readonly", 0),
                                  &error_abort);
3517 3518
                device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                          &error_abort);
3519
                qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
3520
                qemu_opt_set(device, "fsdev",
3521
                             qemu_opts_id(fsdev), &error_abort);
3522
                qemu_opt_set(device, "mount_tag",
3523
                             qemu_opt_get(opts, "mount_tag"), &error_abort);
3524 3525
                break;
            }
3526 3527 3528 3529
            case QEMU_OPTION_virtfs_synth: {
                QemuOpts *fsdev;
                QemuOpts *device;

3530 3531
                fsdev = qemu_opts_create(qemu_find_opts("fsdev"), "v_synth",
                                         1, NULL);
3532
                if (!fsdev) {
3533
                    error_report("duplicate option: %s", "virtfs_synth");
3534 3535
                    exit(1);
                }
3536
                qemu_opt_set(fsdev, "fsdriver", "synth", &error_abort);
3537

3538 3539
                device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                          &error_abort);
3540 3541 3542
                qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
                qemu_opt_set(device, "fsdev", "v_synth", &error_abort);
                qemu_opt_set(device, "mount_tag", "v_synth", &error_abort);
3543 3544
                break;
            }
B
bellard 已提交
3545
            case QEMU_OPTION_serial:
3546 3547
                add_device_config(DEV_SERIAL, optarg);
                default_serial = 0;
3548 3549 3550
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
B
bellard 已提交
3551
                break;
R
Richard W.M. Jones 已提交
3552
            case QEMU_OPTION_watchdog:
3553
                if (watchdog) {
3554
                    error_report("only one watchdog option may be given");
3555 3556 3557
                    return 1;
                }
                watchdog = optarg;
R
Richard W.M. Jones 已提交
3558 3559 3560
                break;
            case QEMU_OPTION_watchdog_action:
                if (select_watchdog_action(optarg) == -1) {
3561
                    error_report("unknown -watchdog-action parameter");
R
Richard W.M. Jones 已提交
3562 3563 3564
                    exit(1);
                }
                break;
3565
            case QEMU_OPTION_virtiocon:
3566 3567
                warn_report("This option is deprecated, "
                            "use '-device virtconsole' instead");
3568 3569
                add_device_config(DEV_VIRTCON, optarg);
                default_virtcon = 0;
3570 3571 3572
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
3573
                break;
3574
            case QEMU_OPTION_parallel:
3575 3576
                add_device_config(DEV_PARALLEL, optarg);
                default_parallel = 0;
3577 3578 3579
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
3580
                break;
3581 3582 3583
            case QEMU_OPTION_debugcon:
                add_device_config(DEV_DEBUGCON, optarg);
                break;
3584 3585 3586
            case QEMU_OPTION_loadvm:
                loadvm = optarg;
                break;
3587
            case QEMU_OPTION_full_screen:
3588 3589
                dpy.has_full_screen = true;
                dpy.full_screen = true;
3590
                break;
3591
            case QEMU_OPTION_no_frame:
G
Gerd Hoffmann 已提交
3592 3593
                g_printerr("The -no-frame switch is deprecated, and will be\n"
                           "removed in a future release.\n");
3594 3595
                no_frame = 1;
                break;
3596 3597 3598
            case QEMU_OPTION_alt_grab:
                alt_grab = 1;
                break;
3599 3600 3601
            case QEMU_OPTION_ctrl_grab:
                ctrl_grab = 1;
                break;
3602
            case QEMU_OPTION_no_quit:
3603 3604
                dpy.has_window_close = true;
                dpy.window_close = false;
3605
                break;
3606
            case QEMU_OPTION_sdl:
3607
#ifdef CONFIG_SDL
G
Gerd Hoffmann 已提交
3608
                dpy.type = DISPLAY_TYPE_SDL;
3609
                break;
3610
#else
3611
                error_report("SDL support is disabled");
3612
                exit(1);
3613
#endif
B
bellard 已提交
3614
            case QEMU_OPTION_pidfile:
3615
                pid_file = optarg;
B
bellard 已提交
3616
                break;
3617 3618 3619
            case QEMU_OPTION_win2k_hack:
                win2k_install_hack = 1;
                break;
3620
            case QEMU_OPTION_acpitable:
3621 3622
                opts = qemu_opts_parse_noisily(qemu_find_opts("acpi"),
                                               optarg, true);
3623 3624 3625
                if (!opts) {
                    exit(1);
                }
3626
                acpi_table_add(opts, &error_fatal);
3627
                break;
3628
            case QEMU_OPTION_smbios:
3629 3630
                opts = qemu_opts_parse_noisily(qemu_find_opts("smbios"),
                                               optarg, false);
3631 3632 3633
                if (!opts) {
                    exit(1);
                }
3634
                smbios_entry_add(opts, &error_fatal);
3635
                break;
3636
            case QEMU_OPTION_fwcfg:
3637 3638
                opts = qemu_opts_parse_noisily(qemu_find_opts("fw_cfg"),
                                               optarg, true);
3639 3640 3641 3642
                if (opts == NULL) {
                    exit(1);
                }
                break;
3643 3644 3645
            case QEMU_OPTION_preconfig:
                preconfig_exit_requested = false;
                break;
A
aliguori 已提交
3646
            case QEMU_OPTION_enable_kvm:
3647
                olist = qemu_find_opts("machine");
3648
                qemu_opts_parse_noisily(olist, "accel=kvm", false);
3649
                break;
3650
            case QEMU_OPTION_enable_hax:
3651
                warn_report("Option is deprecated, use '-accel hax' instead");
3652 3653 3654
                olist = qemu_find_opts("machine");
                qemu_opts_parse_noisily(olist, "accel=hax", false);
                break;
3655
            case QEMU_OPTION_M:
3656 3657
            case QEMU_OPTION_machine:
                olist = qemu_find_opts("machine");
3658
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3659 3660 3661
                if (!opts) {
                    exit(1);
                }
A
aliguori 已提交
3662
                break;
3663 3664
             case QEMU_OPTION_no_kvm:
                olist = qemu_find_opts("machine");
3665
                qemu_opts_parse_noisily(olist, "accel=tcg", false);
3666
                break;
3667
            case QEMU_OPTION_accel:
3668 3669 3670
                accel_opts = qemu_opts_parse_noisily(qemu_find_opts("accel"),
                                                     optarg, true);
                optarg = qemu_opt_get(accel_opts, "accel");
3671 3672
                if (!optarg || is_help_option(optarg)) {
                    error_printf("Possible accelerators: kvm, xen, hax, tcg\n");
3673
                    exit(0);
3674
                }
3675 3676 3677
                opts = qemu_opts_create(qemu_find_opts("machine"), NULL,
                                        false, &error_abort);
                qemu_opt_set(opts, "accel", optarg, &error_abort);
3678
                break;
B
bellard 已提交
3679
            case QEMU_OPTION_usb:
3680
                olist = qemu_find_opts("machine");
3681
                qemu_opts_parse_noisily(olist, "usb=on", false);
B
bellard 已提交
3682
                break;
B
bellard 已提交
3683
            case QEMU_OPTION_usbdevice:
3684 3685
                error_report("'-usbdevice' is deprecated, please use "
                             "'-device usb-...' instead");
3686
                olist = qemu_find_opts("machine");
3687
                qemu_opts_parse_noisily(olist, "usb=on", false);
3688 3689 3690
                add_device_config(DEV_USB, optarg);
                break;
            case QEMU_OPTION_device:
3691 3692
                if (!qemu_opts_parse_noisily(qemu_find_opts("device"),
                                             optarg, true)) {
3693 3694
                    exit(1);
                }
B
bellard 已提交
3695
                break;
B
bellard 已提交
3696
            case QEMU_OPTION_smp:
3697 3698
                if (!qemu_opts_parse_noisily(qemu_find_opts("smp-opts"),
                                             optarg, true)) {
3699 3700
                    exit(1);
                }
B
bellard 已提交
3701
                break;
3702
            case QEMU_OPTION_vnc:
3703
                vnc_parse(optarg, &error_fatal);
J
Jes Sorensen 已提交
3704
                break;
B
bellard 已提交
3705 3706 3707
            case QEMU_OPTION_no_acpi:
                acpi_enabled = 0;
                break;
3708 3709 3710
            case QEMU_OPTION_no_hpet:
                no_hpet = 1;
                break;
B
bellard 已提交
3711 3712 3713
            case QEMU_OPTION_no_reboot:
                no_reboot = 1;
                break;
A
aurel32 已提交
3714 3715 3716
            case QEMU_OPTION_no_shutdown:
                no_shutdown = 1;
                break;
3717 3718 3719
            case QEMU_OPTION_show_cursor:
                cursor_hide = 0;
                break;
3720
            case QEMU_OPTION_uuid:
3721
                if (qemu_uuid_parse(optarg, &qemu_uuid) < 0) {
3722
                    error_report("failed to parse UUID string: wrong format");
3723 3724
                    exit(1);
                }
3725
                qemu_uuid_set = true;
3726
                break;
3727 3728
            case QEMU_OPTION_option_rom:
                if (nb_option_roms >= MAX_OPTION_ROMS) {
3729
                    error_report("too many option ROMs");
3730 3731
                    exit(1);
                }
3732 3733
                opts = qemu_opts_parse_noisily(qemu_find_opts("option-rom"),
                                               optarg, true);
3734 3735 3736
                if (!opts) {
                    exit(1);
                }
3737 3738 3739 3740
                option_rom[nb_option_roms].name = qemu_opt_get(opts, "romfile");
                option_rom[nb_option_roms].bootindex =
                    qemu_opt_get_number(opts, "bootindex", -1);
                if (!option_rom[nb_option_roms].name) {
3741
                    error_report("Option ROM file is not specified");
3742 3743
                    exit(1);
                }
3744 3745
                nb_option_roms++;
                break;
3746
            case QEMU_OPTION_semihosting:
3747 3748
                semihosting.enabled = true;
                semihosting.target = SEMIHOSTING_TARGET_AUTO;
3749 3750
                break;
            case QEMU_OPTION_semihosting_config:
3751
                semihosting.enabled = true;
3752 3753
                opts = qemu_opts_parse_noisily(qemu_find_opts("semihosting-config"),
                                               optarg, false);
3754
                if (opts != NULL) {
3755
                    semihosting.enabled = qemu_opt_get_bool(opts, "enable",
3756 3757 3758 3759
                                                            true);
                    const char *target = qemu_opt_get(opts, "target");
                    if (target != NULL) {
                        if (strcmp("native", target) == 0) {
3760
                            semihosting.target = SEMIHOSTING_TARGET_NATIVE;
3761
                        } else if (strcmp("gdb", target) == 0) {
3762
                            semihosting.target = SEMIHOSTING_TARGET_GDB;
3763
                        } else  if (strcmp("auto", target) == 0) {
3764
                            semihosting.target = SEMIHOSTING_TARGET_AUTO;
3765
                        } else {
3766
                            error_report("unsupported semihosting-config %s",
3767
                                         optarg);
3768 3769 3770
                            exit(1);
                        }
                    } else {
3771
                        semihosting.target = SEMIHOSTING_TARGET_AUTO;
3772
                    }
3773 3774 3775
                    /* Set semihosting argument count and vector */
                    qemu_opt_foreach(opts, add_semihosting_arg,
                                     &semihosting, NULL);
3776
                } else {
3777
                    error_report("unsupported semihosting-config %s", optarg);
3778 3779
                    exit(1);
                }
3780
                break;
3781
            case QEMU_OPTION_name:
3782 3783
                opts = qemu_opts_parse_noisily(qemu_find_opts("name"),
                                               optarg, true);
3784 3785 3786
                if (!opts) {
                    exit(1);
                }
3787
                break;
3788 3789
            case QEMU_OPTION_prom_env:
                if (nb_prom_envs >= MAX_PROM_ENVS) {
3790
                    error_report("too many prom variables");
3791 3792 3793 3794 3795
                    exit(1);
                }
                prom_envs[nb_prom_envs] = optarg;
                nb_prom_envs++;
                break;
3796 3797
            case QEMU_OPTION_old_param:
                old_param = 1;
3798
                break;
3799
            case QEMU_OPTION_clock:
3800 3801 3802
                /* Clock options no longer exist.  Keep this option for
                 * backward compatibility.
                 */
3803
                warn_report("This option is ignored and will be removed soon");
3804
                break;
3805
            case QEMU_OPTION_rtc:
3806 3807
                opts = qemu_opts_parse_noisily(qemu_find_opts("rtc"), optarg,
                                               false);
3808 3809
                if (!opts) {
                    exit(1);
B
bellard 已提交
3810 3811
                }
                break;
3812
            case QEMU_OPTION_tb_size:
3813 3814 3815 3816
#ifndef CONFIG_TCG
                error_report("TCG is disabled");
                exit(1);
#endif
3817 3818 3819
                if (qemu_strtoul(optarg, NULL, 0, &tcg_tb_size) < 0) {
                    error_report("Invalid argument to -tb-size");
                    exit(1);
3820
                }
3821
                break;
P
pbrook 已提交
3822
            case QEMU_OPTION_icount:
3823 3824
                icount_opts = qemu_opts_parse_noisily(qemu_find_opts("icount"),
                                                      optarg, true);
3825 3826 3827
                if (!icount_opts) {
                    exit(1);
                }
P
pbrook 已提交
3828
                break;
3829
            case QEMU_OPTION_incoming:
3830 3831 3832
                if (!incoming) {
                    runstate_set(RUN_STATE_INMIGRATE);
                }
3833 3834
                incoming = optarg;
                break;
3835
            case QEMU_OPTION_only_migratable:
3836 3837 3838 3839 3840 3841
                /*
                 * TODO: we can remove this option one day, and we
                 * should all use:
                 *
                 * "-global migration.only-migratable=true"
                 */
3842
                qemu_global_option("migration.only-migratable=true");
3843
                break;
3844
            case QEMU_OPTION_nodefaults:
3845
                has_defaults = 0;
3846
                break;
3847
            case QEMU_OPTION_xen_domid:
3848
                if (!(xen_available())) {
3849
                    error_report("Option not supported for this target");
3850 3851
                    exit(1);
                }
3852 3853 3854
                xen_domid = atoi(optarg);
                break;
            case QEMU_OPTION_xen_create:
3855
                if (!(xen_available())) {
3856
                    error_report("Option not supported for this target");
3857 3858
                    exit(1);
                }
3859 3860 3861
                xen_mode = XEN_CREATE;
                break;
            case QEMU_OPTION_xen_attach:
3862
                if (!(xen_available())) {
3863
                    error_report("Option not supported for this target");
3864 3865
                    exit(1);
                }
3866 3867
                xen_mode = XEN_ATTACH;
                break;
3868 3869 3870 3871 3872 3873 3874
            case QEMU_OPTION_xen_domid_restrict:
                if (!(xen_available())) {
                    error_report("Option not supported for this target");
                    exit(1);
                }
                xen_domid_restrict = true;
                break;
3875
            case QEMU_OPTION_trace:
3876 3877
                g_free(trace_file);
                trace_file = trace_opt_parse(optarg);
3878
                break;
3879 3880
            case QEMU_OPTION_readconfig:
                {
3881 3882
                    int ret = qemu_read_config_file(optarg);
                    if (ret < 0) {
3883 3884
                        error_report("read config %s: %s", optarg,
                                     strerror(-ret));
3885 3886 3887 3888
                        exit(1);
                    }
                    break;
                }
G
Gerd Hoffmann 已提交
3889 3890 3891
            case QEMU_OPTION_spice:
                olist = qemu_find_opts("spice");
                if (!olist) {
3892
                    error_report("spice support is disabled");
G
Gerd Hoffmann 已提交
3893 3894
                    exit(1);
                }
3895
                opts = qemu_opts_parse_noisily(olist, optarg, false);
G
Gerd Hoffmann 已提交
3896 3897 3898
                if (!opts) {
                    exit(1);
                }
G
Gerd Hoffmann 已提交
3899
                display_remote++;
G
Gerd Hoffmann 已提交
3900
                break;
3901 3902 3903 3904 3905 3906 3907 3908
            case QEMU_OPTION_writeconfig:
                {
                    FILE *fp;
                    if (strcmp(optarg, "-") == 0) {
                        fp = stdout;
                    } else {
                        fp = fopen(optarg, "w");
                        if (fp == NULL) {
3909 3910
                            error_report("open %s: %s", optarg,
                                         strerror(errno));
3911 3912 3913 3914
                            exit(1);
                        }
                    }
                    qemu_config_write(fp);
3915 3916 3917
                    if (fp != stdout) {
                        fclose(fp);
                    }
3918 3919
                    break;
                }
3920 3921 3922 3923 3924 3925
            case QEMU_OPTION_qtest:
                qtest_chrdev = optarg;
                break;
            case QEMU_OPTION_qtest_log:
                qtest_log = optarg;
                break;
3926
            case QEMU_OPTION_sandbox:
3927
#ifdef CONFIG_SECCOMP
3928 3929
                opts = qemu_opts_parse_noisily(qemu_find_opts("sandbox"),
                                               optarg, true);
3930
                if (!opts) {
3931
                    exit(1);
3932
                }
3933 3934 3935 3936 3937
#else
                error_report("-sandbox support is not enabled "
                             "in this QEMU binary");
                exit(1);
#endif
3938
                break;
3939 3940
            case QEMU_OPTION_add_fd:
#ifndef _WIN32
3941 3942
                opts = qemu_opts_parse_noisily(qemu_find_opts("add-fd"),
                                               optarg, false);
3943
                if (!opts) {
3944
                    exit(1);
3945 3946 3947 3948 3949 3950 3951
                }
#else
                error_report("File descriptor passing is disabled on this "
                             "platform");
                exit(1);
#endif
                break;
3952
            case QEMU_OPTION_object:
3953 3954
                opts = qemu_opts_parse_noisily(qemu_find_opts("object"),
                                               optarg, true);
3955 3956 3957
                if (!opts) {
                    exit(1);
                }
3958
                break;
3959
            case QEMU_OPTION_realtime:
3960 3961
                opts = qemu_opts_parse_noisily(qemu_find_opts("realtime"),
                                               optarg, false);
3962 3963 3964
                if (!opts) {
                    exit(1);
                }
3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978
                /* Don't override the -overcommit option if set */
                enable_mlock = enable_mlock ||
                    qemu_opt_get_bool(opts, "mlock", true);
                break;
            case QEMU_OPTION_overcommit:
                opts = qemu_opts_parse_noisily(qemu_find_opts("overcommit"),
                                               optarg, false);
                if (!opts) {
                    exit(1);
                }
                /* Don't override the -realtime option if set */
                enable_mlock = enable_mlock ||
                    qemu_opt_get_bool(opts, "mem-lock", false);
                enable_cpu_pm = qemu_opt_get_bool(opts, "cpu-pm", false);
3979
                break;
3980
            case QEMU_OPTION_msg:
3981 3982
                opts = qemu_opts_parse_noisily(qemu_find_opts("msg"), optarg,
                                               false);
3983 3984 3985 3986 3987
                if (!opts) {
                    exit(1);
                }
                configure_msg(opts);
                break;
3988
            case QEMU_OPTION_dump_vmstate:
3989
                if (vmstate_dump_file) {
3990 3991
                    error_report("only one '-dump-vmstate' "
                                 "option may be given");
3992 3993
                    exit(1);
                }
3994 3995
                vmstate_dump_file = fopen(optarg, "w");
                if (vmstate_dump_file == NULL) {
3996
                    error_report("open %s: %s", optarg, strerror(errno));
3997 3998
                    exit(1);
                }
3999 4000 4001
                break;
            case QEMU_OPTION_enable_sync_profile:
                qsp_enable();
4002
                break;
4003 4004 4005
            case QEMU_OPTION_nouserconfig:
                /* Nothing to be parsed here. Especially, do not error out below. */
                break;
4006
            default:
4007 4008 4009 4010
                if (os_parse_cmd_args(popt->index, optarg)) {
                    error_report("Option not supported in this build");
                    exit(1);
                }
4011
            }
4012 4013
        }
    }
4014 4015 4016 4017 4018
    /*
     * Clear error location left behind by the loop.
     * Best done right after the loop.  Do not insert code here!
     */
    loc_set_none();
4019

4020 4021
    replay_configure(icount_opts);

4022 4023 4024 4025 4026 4027
    if (incoming && !preconfig_exit_requested) {
        error_report("'preconfig' and 'incoming' options are "
                     "mutually exclusive");
        exit(EXIT_FAILURE);
    }

4028 4029
    configure_rtc(qemu_find_opts_singleton("rtc"));

4030
    machine_class = select_machine();
4031 4032

    set_memory_options(&ram_slots, &maxram_size, machine_class);
4033

4034
    os_daemonize();
4035
    rcu_disable_atfork();
4036

4037 4038
    if (pid_file && !qemu_write_pidfile(pid_file, &err)) {
        error_reportf_err(err, "cannot create PID file: ");
4039 4040 4041
        exit(1);
    }

4042 4043 4044
    qemu_unlink_pidfile_notifier.notify = qemu_unlink_pidfile;
    qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier);

4045
    if (qemu_init_main_loop(&main_loop_err)) {
4046
        error_report_err(main_loop_err);
4047 4048 4049
        exit(1);
    }

4050
#ifdef CONFIG_SECCOMP
4051
    olist = qemu_find_opts_err("sandbox", NULL);
4052 4053
    if (olist) {
        qemu_opts_foreach(olist, parse_sandbox, NULL, &error_fatal);
4054
    }
4055
#endif
4056

4057 4058
    qemu_opts_foreach(qemu_find_opts("name"),
                      parse_name, NULL, &error_fatal);
4059

4060
#ifndef _WIN32
4061 4062
    qemu_opts_foreach(qemu_find_opts("add-fd"),
                      parse_add_fd, NULL, &error_fatal);
4063

4064 4065
    qemu_opts_foreach(qemu_find_opts("add-fd"),
                      cleanup_add_fd, NULL, &error_fatal);
4066 4067
#endif

4068 4069
    current_machine = MACHINE(object_new(object_class_get_name(
                          OBJECT_CLASS(machine_class))));
4070 4071 4072
    if (machine_help_func(qemu_get_machine_opts(), current_machine)) {
        exit(0);
    }
4073 4074
    object_property_add_child(object_get_root(), "machine",
                              OBJECT(current_machine), &error_abort);
4075 4076 4077 4078 4079 4080 4081 4082 4083 4084

    if (machine_class->minimum_page_bits) {
        if (!set_preferred_target_page_bits(machine_class->minimum_page_bits)) {
            /* This would be a board error: specifying a minimum smaller than
             * a target's compile-time fixed setting.
             */
            g_assert_not_reached();
        }
    }

4085
    cpu_exec_init_all();
4086

4087
    if (machine_class->hw_version) {
4088
        qemu_set_hw_version(machine_class->hw_version);
4089 4090
    }

4091
    if (cpu_model && is_help_option(cpu_model)) {
4092
        list_cpus(stdout, &fprintf, cpu_model);
4093 4094 4095
        exit(0);
    }

4096 4097 4098
    if (!trace_init_backends()) {
        exit(1);
    }
4099 4100
    trace_init_file(trace_file);

4101
    /* Open the logfile at this point and set the log mask if necessary.
4102
     */
4103
    if (log_file) {
4104
        qemu_set_log_filename(log_file, &error_fatal);
4105 4106
    }

4107
    if (log_mask) {
4108 4109 4110 4111 4112 4113 4114
        int mask;
        mask = qemu_str_to_log_mask(log_mask);
        if (!mask) {
            qemu_print_log_usage(stdout);
            exit(1);
        }
        qemu_set_log(mask);
4115 4116
    } else {
        qemu_set_log(0);
4117
    }
4118

4119 4120 4121 4122 4123
    /* add configured firmware directories */
    dirs = g_strsplit(CONFIG_QEMU_FIRMWAREPATH, G_SEARCHPATH_SEPARATOR_S, 0);
    for (i = 0; dirs[i] != NULL; i++) {
        qemu_add_data_dir(dirs[i]);
    }
4124
    g_strfreev(dirs);
4125 4126

    /* try to find datadir relative to the executable path */
4127 4128 4129
    dir = os_find_datadir();
    qemu_add_data_dir(dir);
    g_free(dir);
G
Gerd Hoffmann 已提交
4130

4131
    /* add the datadir specified when building */
G
Gerd Hoffmann 已提交
4132
    qemu_add_data_dir(CONFIG_QEMU_DATADIR);
P
Paul Brook 已提交
4133

4134 4135 4136 4137 4138 4139 4140 4141
    /* -L help lists the data directories and exits. */
    if (list_data_dirs) {
        for (i = 0; i < data_dir_idx; i++) {
            printf("%s\n", data_dir[i]);
        }
        exit(0);
    }

4142 4143 4144 4145 4146 4147 4148 4149 4150
    /* machine_class: default to UP */
    machine_class->max_cpus = machine_class->max_cpus ?: 1;
    machine_class->min_cpus = machine_class->min_cpus ?: 1;
    machine_class->default_cpus = machine_class->default_cpus ?: 1;

    /* default to machine_class->default_cpus */
    smp_cpus = machine_class->default_cpus;
    max_cpus = machine_class->default_cpus;

4151
    smp_parse(qemu_opts_find(qemu_find_opts("smp-opts"), NULL));
4152

4153 4154 4155 4156 4157 4158 4159
    /* sanity-check smp_cpus and max_cpus against machine_class */
    if (smp_cpus < machine_class->min_cpus) {
        error_report("Invalid SMP CPUs %d. The min CPUs "
                     "supported by machine '%s' is %d", smp_cpus,
                     machine_class->name, machine_class->min_cpus);
        exit(1);
    }
A
Andrew Jones 已提交
4160
    if (max_cpus > machine_class->max_cpus) {
4161 4162
        error_report("Invalid SMP CPUs %d. The max CPUs "
                     "supported by machine '%s' is %d", max_cpus,
4163
                     machine_class->name, machine_class->max_cpus);
4164 4165 4166
        exit(1);
    }

4167 4168 4169 4170
    /*
     * Get the default machine options from the machine if it is not already
     * specified either by the configuration file or by the command line.
     */
4171
    if (machine_class->default_machine_opts) {
4172
        qemu_opts_set_defaults(qemu_find_opts("machine"),
4173
                               machine_class->default_machine_opts, 0);
4174 4175
    }

4176 4177 4178 4179
    qemu_opts_foreach(qemu_find_opts("device"),
                      default_driver_check, NULL, NULL);
    qemu_opts_foreach(qemu_find_opts("global"),
                      default_driver_check, NULL, NULL);
4180

4181 4182 4183
    if (!vga_model && !default_vga) {
        vga_interface_type = VGA_DEVICE;
    }
4184
    if (!has_defaults || machine_class->no_serial) {
4185 4186
        default_serial = 0;
    }
4187
    if (!has_defaults || machine_class->no_parallel) {
4188 4189
        default_parallel = 0;
    }
4190
    if (!has_defaults || !machine_class->use_virtcon) {
4191 4192
        default_virtcon = 0;
    }
4193
    if (!has_defaults || machine_class->no_floppy) {
4194 4195
        default_floppy = 0;
    }
4196
    if (!has_defaults || machine_class->no_cdrom) {
4197 4198
        default_cdrom = 0;
    }
4199
    if (!has_defaults || machine_class->no_sdcard) {
4200 4201
        default_sdcard = 0;
    }
4202 4203 4204 4205 4206
    if (!has_defaults) {
        default_monitor = 0;
        default_net = 0;
        default_vga = 0;
    }
4207

4208
    if (is_daemonized()) {
4209 4210 4211 4212 4213 4214
        if (!preconfig_exit_requested) {
            error_report("'preconfig' and 'daemonize' options are "
                         "mutually exclusive");
            exit(EXIT_FAILURE);
        }

4215 4216 4217 4218 4219 4220 4221 4222 4223
        /* According to documentation and historically, -nographic redirects
         * serial port, parallel port and monitor to stdio, which does not work
         * with -daemonize.  We can redirect these to null instead, but since
         * -nographic is legacy, let's just error out.
         * We disallow -nographic only if all other ports are not redirected
         * explicitly, to not break existing legacy setups which uses
         * -nographic _and_ redirects all ports explicitly - this is valid
         * usage, -nographic is just a no-op in this case.
         */
4224
        if (nographic
4225 4226
            && (default_parallel || default_serial
                || default_monitor || default_virtcon)) {
4227
            error_report("-nographic cannot be used with -daemonize");
4228 4229 4230
            exit(1);
        }
#ifdef CONFIG_CURSES
4231
        if (dpy.type == DISPLAY_TYPE_CURSES) {
4232
            error_report("curses display cannot be used with -daemonize");
4233 4234 4235 4236 4237
            exit(1);
        }
#endif
    }

4238
    if (nographic) {
4239 4240
        if (default_parallel)
            add_device_config(DEV_PARALLEL, "null");
G
Gerd Hoffmann 已提交
4241 4242
        if (default_serial && default_monitor) {
            add_device_config(DEV_SERIAL, "mon:stdio");
4243 4244
        } else if (default_virtcon && default_monitor) {
            add_device_config(DEV_VIRTCON, "mon:stdio");
G
Gerd Hoffmann 已提交
4245 4246 4247
        } else {
            if (default_serial)
                add_device_config(DEV_SERIAL, "stdio");
4248 4249
            if (default_virtcon)
                add_device_config(DEV_VIRTCON, "stdio");
G
Gerd Hoffmann 已提交
4250
            if (default_monitor)
M
Max Reitz 已提交
4251
                monitor_parse("stdio", "readline", false);
G
Gerd Hoffmann 已提交
4252
        }
4253 4254 4255
    } else {
        if (default_serial)
            add_device_config(DEV_SERIAL, "vc:80Cx24C");
4256 4257
        if (default_parallel)
            add_device_config(DEV_PARALLEL, "vc:80Cx24C");
4258
        if (default_monitor)
M
Max Reitz 已提交
4259
            monitor_parse("vc:80Cx24C", "readline", false);
4260 4261
        if (default_virtcon)
            add_device_config(DEV_VIRTCON, "vc:80Cx24C");
4262 4263
    }

G
Gerd Hoffmann 已提交
4264 4265 4266 4267 4268
#if defined(CONFIG_VNC)
    if (!QTAILQ_EMPTY(&(qemu_find_opts("vnc")->head))) {
        display_remote++;
    }
#endif
4269
    if (dpy.type == DISPLAY_TYPE_DEFAULT && !display_remote) {
4270 4271 4272 4273
        if (!qemu_display_find_default(&dpy)) {
            dpy.type = DISPLAY_TYPE_NONE;
#if defined(CONFIG_VNC)
            vnc_parse("localhost:0,to=99,id=default", &error_abort);
4274
#endif
4275
        }
4276
    }
4277 4278
    if (dpy.type == DISPLAY_TYPE_DEFAULT) {
        dpy.type = DISPLAY_TYPE_NONE;
4279 4280
    }

4281
    if ((no_frame || alt_grab || ctrl_grab) && dpy.type != DISPLAY_TYPE_SDL) {
4282 4283
        error_report("-no-frame, -alt-grab and -ctrl-grab are only valid "
                     "for SDL, ignoring option");
4284
    }
4285
    if (dpy.has_window_close &&
4286
        (dpy.type != DISPLAY_TYPE_GTK && dpy.type != DISPLAY_TYPE_SDL)) {
4287 4288
        error_report("-no-quit is only valid for GTK and SDL, "
                     "ignoring option");
4289 4290
    }

4291
    qemu_display_early_init(&dpy);
M
Marc-André Lureau 已提交
4292 4293
    qemu_console_early_init();

4294
    if (dpy.has_gl && dpy.gl != DISPLAYGL_MODE_OFF && display_opengl == 0) {
4295
#if defined(CONFIG_OPENGL)
4296
        error_report("OpenGL is not supported by the display");
4297
#else
4298
        error_report("OpenGL support is disabled");
4299 4300 4301
#endif
        exit(1);
    }
4302

4303
    page_size_init();
T
TeLeMan 已提交
4304 4305
    socket_init();

4306 4307 4308
    qemu_opts_foreach(qemu_find_opts("object"),
                      user_creatable_add_opts_foreach,
                      object_create_initial, &error_fatal);
4309

4310 4311
    qemu_opts_foreach(qemu_find_opts("chardev"),
                      chardev_init_func, NULL, &error_fatal);
4312

4313
#ifdef CONFIG_VIRTFS
4314 4315
    qemu_opts_foreach(qemu_find_opts("fsdev"),
                      fsdev_init_func, NULL, &error_fatal);
4316
#endif
4317

4318 4319
    if (qemu_opts_foreach(qemu_find_opts("device"),
                          device_help_func, NULL, NULL)) {
4320 4321 4322
        exit(0);
    }

4323
    machine_opts = qemu_get_machine_opts();
4324 4325
    qemu_opt_foreach(machine_opts, machine_set_property, current_machine,
                     &error_fatal);
4326

4327
    configure_accelerator(current_machine);
M
Marcelo Tosatti 已提交
4328

4329 4330 4331 4332 4333
    if (!qtest_enabled() && machine_class->deprecation_reason) {
        error_report("Machine type '%s' is deprecated: %s",
                     machine_class->name, machine_class->deprecation_reason);
    }

4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345
    /*
     * Register all the global properties, including accel properties,
     * machine properties, and user-specified ones.
     */
    register_global_properties(current_machine);

    /*
     * Migration object can only be created after global properties
     * are applied correctly.
     */
    migration_object_init();

4346
    if (qtest_chrdev) {
4347
        qtest_init(qtest_chrdev, qtest_log, &error_fatal);
4348 4349
    }

4350 4351 4352 4353
    machine_opts = qemu_get_machine_opts();
    kernel_filename = qemu_opt_get(machine_opts, "kernel");
    initrd_filename = qemu_opt_get(machine_opts, "initrd");
    kernel_cmdline = qemu_opt_get(machine_opts, "append");
4354
    bios_name = qemu_opt_get(machine_opts, "firmware");
4355

4356 4357
    opts = qemu_opts_find(qemu_find_opts("boot-opts"), NULL);
    if (opts) {
4358 4359
        boot_order = qemu_opt_get(opts, "order");
        if (boot_order) {
4360
            validate_bootdevices(boot_order, &error_fatal);
4361 4362
        }

4363 4364
        boot_once = qemu_opt_get(opts, "once");
        if (boot_once) {
4365
            validate_bootdevices(boot_once, &error_fatal);
4366 4367 4368
        }

        boot_menu = qemu_opt_get_bool(opts, "menu", boot_menu);
4369
        boot_strict = qemu_opt_get_bool(opts, "strict", false);
4370 4371
    }

4372 4373 4374 4375
    if (!boot_order) {
        boot_order = machine_class->default_boot_order;
    }

4376 4377
    if (!kernel_cmdline) {
        kernel_cmdline = "";
4378
        current_machine->kernel_cmdline = (char *)kernel_cmdline;
4379 4380
    }

4381
    linux_boot = (kernel_filename != NULL);
4382

4383
    if (!linux_boot && *kernel_cmdline != '\0') {
4384
        error_report("-append only allowed with -kernel option");
4385 4386 4387 4388
        exit(1);
    }

    if (!linux_boot && initrd_filename != NULL) {
4389
        error_report("-initrd only allowed with -kernel option");
4390 4391 4392
        exit(1);
    }

4393 4394 4395 4396 4397
    if (semihosting_enabled() && !semihosting_get_argc() && kernel_filename) {
        /* fall back to the -kernel/-append */
        semihosting_arg_fallback(kernel_filename, kernel_cmdline);
    }

4398
    os_set_line_buffering();
4399

4400 4401 4402
    /* spice needs the timers to be initialized by this point */
    qemu_spice_init();

4403
    cpu_ticks_init();
4404
    if (icount_opts) {
4405 4406
        if (!tcg_enabled()) {
            error_report("-icount is not allowed with hardware virtualization");
4407 4408 4409 4410
            exit(1);
        }
        configure_icount(icount_opts, &error_abort);
        qemu_opts_del(icount_opts);
4411
    }
4412

4413 4414 4415
    if (tcg_enabled()) {
        qemu_tcg_configure(accel_opts, &error_fatal);
    }
4416

4417 4418 4419 4420 4421 4422 4423 4424
    if (default_net) {
        QemuOptsList *net = qemu_find_opts("net");
        qemu_opts_set(net, NULL, "type", "nic", &error_abort);
#ifdef CONFIG_SLIRP
        qemu_opts_set(net, NULL, "type", "user", &error_abort);
#endif
    }

4425 4426
    if (net_init_clients(&err) < 0) {
        error_report_err(err);
4427
        exit(1);
B
bellard 已提交
4428
    }
B
bellard 已提交
4429

4430 4431 4432
    qemu_opts_foreach(qemu_find_opts("object"),
                      user_creatable_add_opts_foreach,
                      object_create_delayed, &error_fatal);
4433

4434
    tpm_init();
4435

4436
    /* init the bluetooth world */
4437 4438
    if (foreach_device_config(DEV_BT, bt_parse))
        exit(1);
4439

4440 4441 4442
    if (!xen_enabled()) {
        /* On 32-bit hosts, QEMU is limited by virtual address space */
        if (ram_size > (2047 << 20) && HOST_LONG_BITS == 32) {
4443
            error_report("at most 2047 MB RAM can be simulated");
4444 4445 4446
            exit(1);
        }
    }
4447

L
lirans@il.ibm.com 已提交
4448
    blk_mig_init();
4449
    ram_mig_init();
4450
    dirty_bitmap_mig_init();
L
lirans@il.ibm.com 已提交
4451

4452 4453 4454 4455 4456 4457 4458
    /* If the currently selected machine wishes to override the units-per-bus
     * property of its default HBA interface type, do so now. */
    if (machine_class->units_per_default_bus) {
        override_max_devs(machine_class->block_default_type,
                          machine_class->units_per_default_bus);
    }

4459
    /* open the virtual block devices */
4460 4461 4462 4463 4464 4465 4466 4467 4468 4469
    while (!QSIMPLEQ_EMPTY(&bdo_queue)) {
        BlockdevOptions_queue *bdo = QSIMPLEQ_FIRST(&bdo_queue);

        QSIMPLEQ_REMOVE_HEAD(&bdo_queue, entry);
        loc_push_restore(&bdo->loc);
        qmp_blockdev_add(bdo->bdo, &error_fatal);
        loc_pop(&bdo->loc);
        qapi_free_BlockdevOptions(bdo->bdo);
        g_free(bdo);
    }
4470 4471 4472 4473
    if (snapshot || replay_mode != REPLAY_MODE_NONE) {
        qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot,
                          NULL, NULL);
    }
4474
    if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func,
4475 4476
                          &machine_class->block_default_type, &error_fatal)) {
        /* We printed help */
4477
        exit(0);
4478
    }
4479

4480
    default_drive(default_cdrom, snapshot, machine_class->block_default_type, 2,
4481 4482 4483
                  CDROM_OPTS);
    default_drive(default_floppy, snapshot, IF_FLOPPY, 0, FD_OPTS);
    default_drive(default_sdcard, snapshot, IF_SD, 0, SD_OPTS);
4484

4485 4486
    qemu_opts_foreach(qemu_find_opts("mon"),
                      mon_init_func, NULL, &error_fatal);
4487

4488 4489
    if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
        exit(1);
4490 4491
    if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
        exit(1);
4492 4493
    if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
        exit(1);
4494 4495
    if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
        exit(1);
4496

4497
    /* If no default VGA is requested, the default is "none".  */
4498
    if (default_vga) {
4499 4500
        if (machine_class->default_display) {
            vga_model = machine_class->default_display;
4501
        } else if (vga_interface_available(VGA_CIRRUS)) {
4502
            vga_model = "cirrus";
4503
        } else if (vga_interface_available(VGA_STD)) {
4504 4505
            vga_model = "std";
        }
B
Blue Swirl 已提交
4506
    }
4507 4508 4509
    if (vga_model) {
        select_vgahw(vga_model);
    }
B
Blue Swirl 已提交
4510

4511 4512 4513 4514 4515 4516
    if (watchdog) {
        i = select_watchdog(watchdog);
        if (i > 0)
            exit (i == 1 ? 1 : 0);
    }

P
Pavel Dovgalyuk 已提交
4517 4518 4519 4520
    /* This checkpoint is required by replay to separate prior clock
       reading from the other reads, because timer polling functions query
       clock values from the log. */
    replay_checkpoint(CHECKPOINT_INIT);
4521 4522
    qdev_machine_init();

4523
    current_machine->ram_size = ram_size;
4524 4525
    current_machine->maxram_size = maxram_size;
    current_machine->ram_slots = ram_slots;
4526 4527
    current_machine->boot_order = boot_order;

4528
    /* parse features once if machine provides default cpu_type */
4529 4530 4531
    current_machine->cpu_type = machine_class->default_cpu_type;
    if (cpu_model) {
        current_machine->cpu_type = parse_cpu_model(cpu_model);
4532
    }
4533
    parse_numa_opts(current_machine);
4534

4535 4536 4537 4538
    /* do monitor/qmp handling at preconfig state if requested */
    main_loop();

    /* from here on runstate is RUN_STATE_PRELAUNCH */
4539
    machine_run_board_init(current_machine);
4540

4541 4542
    realtime_init();

4543
    soundhw_init();
4544

4545 4546 4547 4548
    if (hax_enabled()) {
        hax_sync_vcpus();
    }

4549 4550
    qemu_opts_foreach(qemu_find_opts("fw_cfg"),
                      parse_fw_cfg, fw_cfg_find(), &error_fatal);
4551

4552
    /* init USB devices */
4553
    if (machine_usb(current_machine)) {
4554 4555
        if (foreach_device_config(DEV_USB, usb_parse) < 0)
            exit(1);
4556 4557
    }

4558 4559 4560
    /* Check if IGD GFX passthrough. */
    igd_gfx_passthru();

4561
    /* init generic devices */
4562
    rom_set_order_override(FW_CFG_ORDER_OVERRIDE_DEVICE);
4563 4564
    qemu_opts_foreach(qemu_find_opts("device"),
                      device_init_func, NULL, &error_fatal);
4565

4566 4567
    cpu_synchronize_all_post_init();

4568
    rom_reset_order_override();
4569

4570 4571 4572
    /* Did we create any drives that we failed to create a device for? */
    drive_check_orphaned();

4573 4574 4575 4576 4577 4578 4579 4580
    /* Don't warn about the default network setup that you get if
     * no command line -net or -netdev options are specified. There
     * are two cases that we would otherwise complain about:
     * (1) board doesn't support a NIC but the implicit "-net nic"
     * requested one
     * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
     * sets up a nic that isn't connected to anything.
     */
4581
    if (!default_net && (!qtest_enabled() || has_defaults)) {
4582 4583 4584
        net_check_clients();
    }

4585
    if (boot_once) {
4586
        qemu_boot_set(boot_once, &error_fatal);
4587 4588 4589
        qemu_register_reset(restore_boot_order, g_strdup(boot_order));
    }

4590
    /* init local displays */
4591 4592
    ds = init_displaystate();
    qemu_display_init(ds, &dpy);
4593

4594 4595 4596
    /* must be after terminal init, SDL library changes signal handlers */
    os_setup_signal_handling();

4597
    /* init remote displays */
4598
#ifdef CONFIG_VNC
4599
    qemu_opts_foreach(qemu_find_opts("vnc"),
4600
                      vnc_init_func, NULL, &error_fatal);
4601
#endif
4602

4603 4604
    if (using_spice) {
        qemu_spice_display_init();
G
Gerd Hoffmann 已提交
4605
    }
4606

4607
    if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) {
4608
        exit(1);
4609 4610
    }

4611 4612
    qdev_machine_creation_done();

4613 4614 4615
    /* TODO: once all bus devices are qdevified, this should be done
     * when bus is created by qdev.c */
    qemu_register_reset(qbus_reset_all_fn, sysbus_get_default());
4616 4617
    qemu_run_machine_init_done_notifiers();

4618
    if (rom_check_and_register_reset() != 0) {
4619
        error_report("rom check and register reset failed");
4620 4621
        exit(1);
    }
4622

4623 4624
    replay_start();

P
Pavel Dovgalyuk 已提交
4625 4626 4627 4628
    /* This checkpoint is required by replay to separate prior clock
       reading from the other reads, because timer polling functions query
       clock values from the log. */
    replay_checkpoint(CHECKPOINT_RESET);
4629
    qemu_system_reset(SHUTDOWN_CAUSE_NONE);
4630
    register_global_state();
4631
    if (loadvm) {
4632
        Error *local_err = NULL;
4633
        if (load_snapshot(loadvm, &local_err) < 0) {
4634
            error_report_err(local_err);
4635
            autostart = 0;
4636
            exit(1);
4637 4638
        }
    }
4639 4640 4641
    if (replay_mode != REPLAY_MODE_NONE) {
        replay_vmstate_init();
    }
4642

4643
    qdev_prop_check_globals();
4644 4645 4646 4647 4648
    if (vmstate_dump_file) {
        /* dump and exit */
        dump_vmstate_json_to_file(vmstate_dump_file);
        return 0;
    }
4649

G
Glauber Costa 已提交
4650
    if (incoming) {
4651 4652 4653
        Error *local_err = NULL;
        qemu_start_incoming_migration(incoming, &local_err);
        if (local_err) {
4654
            error_reportf_err(local_err, "-incoming %s: ", incoming);
4655
            exit(1);
4656
        }
4657
    } else if (autostart) {
4658
        vm_start();
4659
    }
4660

4661
    accel_setup_post(current_machine);
4662
    os_setup_post();
4663

4664
    main_loop();
4665

4666 4667
    gdbserver_cleanup();

4668 4669 4670
    /* No more vcpu or device emulation activity beyond this point */
    vm_shutdown();

4671
    job_cancel_sync_all();
4672
    bdrv_close_all();
4673

4674
    res_free();
4675

4676
    /* vhost-user must be cleaned up before chardevs.  */
4677
    tpm_cleanup();
4678
    net_cleanup();
4679
    audio_cleanup();
4680
    monitor_cleanup();
4681
    qemu_chr_cleanup();
4682
    user_creatable_cleanup();
4683
    migration_object_finalize();
4684
    /* TODO: unref root container, check all devices are ok */
4685

4686 4687
    return 0;
}
反馈
建议
客服 返回
顶部