vl.c 137.6 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

196
int icount_align_option;
197

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

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

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

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

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

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

250 251 252
static QemuOptsList qemu_rtc_opts = {
    .name = "rtc",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_rtc_opts.head),
253
    .merge_lists = true,
254 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
    .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 = {
291 292 293 294 295 296
        /*
         * no elements => accept any
         * sanity checking will happen later
         * when setting machine properties
         */
        { }
297 298 299
    },
};

300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
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 */ }
    },
};

320 321
static QemuOptsList qemu_boot_opts = {
    .name = "boot-opts",
322 323
    .implied_opt_name = "order",
    .merge_lists = true,
324 325 326 327 328 329 330 331 332 333
    .head = QTAILQ_HEAD_INITIALIZER(qemu_boot_opts.head),
    .desc = {
        {
            .name = "order",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "once",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "menu",
334
            .type = QEMU_OPT_BOOL,
335 336 337 338 339 340 341 342 343
        }, {
            .name = "splash",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "splash-time",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "reboot-timeout",
            .type = QEMU_OPT_STRING,
344 345
        }, {
            .name = "strict",
346
            .type = QEMU_OPT_BOOL,
347 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
        },
        { /*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 = {
        { }
    },
};

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

392 393 394 395 396 397 398 399 400 401 402 403
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 */ }
    },
};

404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
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 */ }
    },
};

420 421 422 423 424 425 426 427 428 429 430 431
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 */ }
    },
};

432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
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",
448 449 450 451 452 453
        }, {
            .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.",
454 455 456 457 458
        },
        { /* End of list */ }
    },
};

459 460 461 462 463 464 465 466 467 468
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,
        },
469 470 471 472 473 474 475 476
        {
            .name = "slots",
            .type = QEMU_OPT_NUMBER,
        },
        {
            .name = "maxmem",
            .type = QEMU_OPT_SIZE,
        },
477 478 479 480
        { /* end of list */ }
    },
};

481 482 483 484 485 486 487 488 489
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,
490 491 492
        }, {
            .name = "align",
            .type = QEMU_OPT_BOOL,
493 494 495
        }, {
            .name = "sleep",
            .type = QEMU_OPT_BOOL,
496 497 498 499 500 501
        }, {
            .name = "rr",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "rrfile",
            .type = QEMU_OPT_STRING,
502 503 504
        }, {
            .name = "rrsnapshot",
            .type = QEMU_OPT_STRING,
505 506 507 508 509
        },
        { /* end of list */ }
    },
};

510 511 512 513 514 515 516 517 518 519 520
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,
521 522 523
        }, {
            .name = "arg",
            .type = QEMU_OPT_STRING,
524 525 526 527 528
        },
        { /* end of list */ }
    },
};

529 530 531 532 533 534 535 536 537 538 539 540
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,
541
            .help = "Sets the name of the file from which "
542
                    "the fw_cfg blob will be loaded",
543 544 545 546
        }, {
            .name = "string",
            .type = QEMU_OPT_STRING,
            .help = "Sets content of the blob to be inserted from a string",
547 548 549 550 551
        },
        { /* end of list */ }
    },
};

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

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

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

573
static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp)
574 575 576 577 578 579 580 581 582 583 584 585 586 587
{
    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;
}

588 589 590
/***********************************************************/
/* QEMU state */

591
static RunState current_run_state = RUN_STATE_PRECONFIG;
592

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

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

static const RunStateTransition runstate_transitions_def[] = {
    /*     from      ->     to      */
604 605 606 607 608 609 610
    { 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 },

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

615 616
    { RUN_STATE_INMIGRATE, RUN_STATE_INTERNAL_ERROR },
    { RUN_STATE_INMIGRATE, RUN_STATE_IO_ERROR },
617
    { RUN_STATE_INMIGRATE, RUN_STATE_PAUSED },
618 619 620 621 622
    { 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 },
623
    { RUN_STATE_INMIGRATE, RUN_STATE_FINISH_MIGRATE },
624 625
    { RUN_STATE_INMIGRATE, RUN_STATE_PRELAUNCH },
    { RUN_STATE_INMIGRATE, RUN_STATE_POSTMIGRATE },
626
    { RUN_STATE_INMIGRATE, RUN_STATE_COLO },
627

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

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

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

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

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

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

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

659 660
    { RUN_STATE_COLO, RUN_STATE_RUNNING },

661 662 663 664 665 666 667 668 669
    { 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 },
670
    { RUN_STATE_RUNNING, RUN_STATE_GUEST_PANICKED },
671
    { RUN_STATE_RUNNING, RUN_STATE_COLO},
672

673
    { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING },
674

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

679 680 681 682
    { 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 },
683
    { RUN_STATE_SUSPENDED, RUN_STATE_PRELAUNCH },
684
    { RUN_STATE_SUSPENDED, RUN_STATE_COLO},
685

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

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

695
    { RUN_STATE__MAX, RUN_STATE__MAX },
696 697
};

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

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

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

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

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

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

    qemu_mutex_init(&vmstop_lock);
727 728 729
}

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

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

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

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

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

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

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

    return info;
768 769
}

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

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();
}

791
/***********************************************************/
792
/* RTC reference time/date access */
793
static time_t qemu_ref_timedate(QEMUClockType clock)
794
{
795 796
    time_t value = qemu_clock_get_ms(clock) / 1000;
    switch (clock) {
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
    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;
812 813
}

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

    ti += offset;
819 820

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

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

835
    switch (rtc_base_type) {
836
    case RTC_BASE_DATETIME:
837 838 839 840 841 842 843 844 845 846 847 848 849
    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();
    }
850

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

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

859 860 861 862 863 864 865 866
    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;
867
    } else {
868 869 870 871
        goto date_fail;
    }
    tm.tm_year -= 1900;
    tm.tm_mon--;
872 873
    rtc_start_datetime = mktimegm(&tm);
    if (rtc_start_datetime == -1) {
874
    date_fail:
875
        error_report("invalid datetime format");
876 877 878
        error_printf("valid formats: "
                     "'2006-06-17T16:01:21' or '2006-06-17'\n");
        exit(1);
879
    }
880 881
    rtc_host_datetime_offset = rtc_ref_start_datetime - rtc_start_datetime;
    rtc_ref_start_datetime = rtc_start_datetime;
882 883 884 885 886 887
}

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

888 889 890 891 892
    /* 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;

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

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

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

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

    return hci_table[cur_hci++];
}

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

    if (nb_hcis >= MAX_NICS) {
960
        error_report("too many bluetooth HCIs (max %i)", MAX_NICS);
961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
        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)
986 987
        warn_report("adding a VHCI to an empty scatternet %i",
                    vlan_id);
988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004

    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) {
1005
            error_report("unrecognised bluetooth vlan Id");
1006 1007 1008 1009 1010 1011 1012
            return 0;
        }
    }

    vlan = qemu_find_bt_vlan(vlan_id);

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

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

1019
    error_report("unsupported bluetooth device '%s'", devname);
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
    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) {
1042
                        error_report("bad scatternet '%s'", p);
1043 1044 1045
                        return 1;
                    }
                } else {
1046
                    error_report("bad parameter '%s'", endp + 1);
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
                    return 1;
                }
            } else
                vlan = 0;

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

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

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

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

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

    return 0;
1077 1078
}

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

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

    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) {
1097
        error_setg(errp, "fd option is required and must be non-negative");
1098 1099 1100 1101
        return -1;
    }

    if (fd <= STDERR_FILENO) {
1102
        error_setg(errp, "fd cannot be a standard I/O stream");
1103 1104 1105 1106 1107 1108 1109 1110 1111
        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)) {
1112
        error_setg(errp, "fd is not valid or already in use");
1113 1114 1115 1116
        return -1;
    }

    if (fdset_id < 0) {
1117
        error_setg(errp, "set option is required and must be non-negative");
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
        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) {
1130
        error_setg(errp, "error duplicating fd: %s", strerror(errno));
1131 1132 1133 1134
        return -1;
    }

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

    return 0;
}

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

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

    return 0;
}
#endif

1153 1154 1155
/***********************************************************/
/* QEMU Block devices */

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

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

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

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

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

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

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

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

1196 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
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)
1225
{
1226 1227 1228 1229 1230 1231 1232 1233 1234
    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;
1235
            threads = threads > 0 ? threads : 1;
1236
            if (cpus == 0) {
1237
                sockets = sockets > 0 ? sockets : 1;
1238
                cpus = cores * threads * sockets;
1239 1240 1241
            } else {
                max_cpus = qemu_opt_get_number(opts, "maxcpus", cpus);
                sockets = max_cpus / (cores * threads);
1242
            }
1243 1244 1245
        } else if (cores == 0) {
            threads = threads > 0 ? threads : 1;
            cores = cpus / (sockets * threads);
1246
            cores = cores > 0 ? cores : 1;
1247
        } else if (threads == 0) {
1248
            threads = cpus / (cores * sockets);
1249
            threads = threads > 0 ? threads : 1;
1250
        } else if (sockets * cores * threads < cpus) {
1251 1252 1253 1254
            error_report("cpu topology: "
                         "sockets (%u) * cores (%u) * threads (%u) < "
                         "smp_cpus (%u)",
                         sockets, cores, threads, cpus);
1255
            exit(1);
1256
        }
1257

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

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

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

1273 1274 1275 1276 1277 1278 1279
        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);
        }

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

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

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

1302 1303 1304 1305 1306 1307

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

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

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

static SemihostingConfig semihosting;

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

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

1331 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
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, " ");
    }
}

1383 1384 1385 1386 1387 1388 1389
/* 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 已提交
1390 1391 1392
/***********************************************************/
/* USB devices */

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

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

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

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

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

1418 1419 1420
/***********************************************************/
/* machine registration */

1421
MachineState *current_machine;
1422

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1508 1509
    object_property_iter_init(&iter, OBJECT(machine));
    while ((prop = object_property_iter_next(&iter))) {
1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
        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;
}

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

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

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

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

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

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

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

1557
    trace_vm_state_notify(running, state);
1558

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;

1670 1671
    cpu_synchronize_all_states();

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

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

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

    if (info) {
1700
        if (info->type == GUEST_PANIC_INFORMATION_TYPE_HYPER_V) {
1701
            qemu_log_mask(LOG_GUEST_ERROR, "\nHV crash parameters: (%#"PRIx64
1702
                          " %#"PRIx64" %#"PRIx64" %#"PRIx64" %#"PRIx64")\n",
1703 1704 1705 1706 1707
                          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);
1708 1709 1710 1711 1712 1713 1714
        } 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);
1715
        }
1716 1717
        qapi_free_GuestPanicInformation(info);
    }
1718 1719
}

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

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

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

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

void qemu_system_wakeup_request(WakeupReason reason)
{
1756 1757
    trace_system_wakeup_request(reason);

1758
    if (!runstate_check(RUN_STATE_SUSPENDED)) {
1759 1760 1761 1762 1763
        return;
    }
    if (!(wakeup_reason_mask & (1 << reason))) {
        return;
    }
1764
    runstate_set(RUN_STATE_RUNNING);
L
Liu, Jinsong 已提交
1765
    wakeup_reason = reason;
1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
    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);
}

1783 1784 1785 1786
void qemu_system_killed(int signal, pid_t pid)
{
    shutdown_signal = signal;
    shutdown_pid = pid;
1787
    no_shutdown = 0;
P
Pavel Dovgalyuk 已提交
1788 1789 1790 1791

    /* Cannot call qemu_system_shutdown_request directly because
     * we are in a signal handler.
     */
1792
    shutdown_requested = SHUTDOWN_CAUSE_HOST_SIGNAL;
P
Pavel Dovgalyuk 已提交
1793
    qemu_notify_event();
1794 1795
}

1796
void qemu_system_shutdown_request(ShutdownCause reason)
1797
{
1798 1799 1800
    trace_qemu_system_shutdown_request(reason);
    replay_shutdown_request(reason);
    shutdown_requested = reason;
1801
    qemu_notify_event();
1802 1803
}

1804 1805
static void qemu_system_powerdown(void)
{
1806
    qapi_event_send_powerdown();
1807 1808 1809
    notifier_list_notify(&powerdown_notifiers, NULL);
}

B
bellard 已提交
1810 1811
void qemu_system_powerdown_request(void)
{
1812
    trace_qemu_system_powerdown_request();
B
bellard 已提交
1813
    powerdown_requested = 1;
1814 1815 1816
    qemu_notify_event();
}

1817 1818 1819 1820 1821
void qemu_register_powerdown_notifier(Notifier *notifier)
{
    notifier_list_add(&powerdown_notifiers, notifier);
}

1822 1823 1824
void qemu_system_debug_request(void)
{
    debug_requested = 1;
1825
    qemu_notify_event();
1826 1827
}

1828 1829 1830
static bool main_loop_should_exit(void)
{
    RunState r;
1831 1832
    ShutdownCause request;

1833 1834 1835 1836 1837 1838 1839
    if (preconfig_exit_requested) {
        if (runstate_check(RUN_STATE_PRECONFIG)) {
            runstate_set(RUN_STATE_PRELAUNCH);
        }
        preconfig_exit_requested = false;
        return true;
    }
1840 1841 1842
    if (qemu_debug_requested()) {
        vm_stop(RUN_STATE_DEBUG);
    }
1843 1844 1845
    if (qemu_suspend_requested()) {
        qemu_system_suspend();
    }
1846 1847
    request = qemu_shutdown_requested();
    if (request) {
1848
        qemu_kill_report();
1849
        qapi_event_send_shutdown(shutdown_caused_by_guest(request));
1850 1851 1852 1853 1854 1855
        if (no_shutdown) {
            vm_stop(RUN_STATE_SHUTDOWN);
        } else {
            return true;
        }
    }
1856 1857
    request = qemu_reset_requested();
    if (request) {
1858
        pause_all_vcpus();
1859
        qemu_system_reset(request);
1860
        resume_all_vcpus();
1861 1862 1863
        if (!runstate_check(RUN_STATE_RUNNING) &&
                !runstate_check(RUN_STATE_INMIGRATE)) {
            runstate_set(RUN_STATE_PRELAUNCH);
1864 1865
        }
    }
1866 1867
    if (qemu_wakeup_requested()) {
        pause_all_vcpus();
1868
        qemu_system_reset(SHUTDOWN_CAUSE_NONE);
L
Liu, Jinsong 已提交
1869 1870
        notifier_list_notify(&wakeup_notifiers, &wakeup_reason);
        wakeup_reason = QEMU_WAKEUP_REASON_NONE;
1871
        resume_all_vcpus();
1872
        qapi_event_send_wakeup();
1873
    }
1874
    if (qemu_powerdown_requested()) {
1875
        qemu_system_powerdown();
1876 1877 1878 1879 1880 1881 1882
    }
    if (qemu_vmstop_requested(&r)) {
        vm_stop(r);
    }
    return false;
}

1883 1884
static void main_loop(void)
{
1885 1886 1887
#ifdef CONFIG_PROFILER
    int64_t ti;
#endif
1888
    while (!main_loop_should_exit()) {
1889
#ifdef CONFIG_PROFILER
J
Jan Kiszka 已提交
1890
        ti = profile_getclock();
1891
#endif
1892
        main_loop_wait(false);
1893
#ifdef CONFIG_PROFILER
J
Jan Kiszka 已提交
1894
        dev_time += profile_getclock() - ti;
1895
#endif
1896
    }
B
bellard 已提交
1897 1898
}

P
pbrook 已提交
1899 1900
static void version(void)
{
1901
    printf("QEMU emulator version " QEMU_FULL_VERSION "\n"
1902
           QEMU_COPYRIGHT "\n");
P
pbrook 已提交
1903 1904
}

1905
static void help(int exitcode)
1906
{
1907 1908 1909 1910 1911
    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());

1912 1913
#define QEMU_OPTIONS_GENERATE_HELP
#include "qemu-options-wrapper.h"
1914 1915

    printf("\nDuring emulation, the following keys are useful:\n"
1916 1917 1918 1919
           "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"
1920 1921 1922
           "When using -nographic, press 'ctrl-a h' to get some help.\n"
           "\n"
           QEMU_HELP_BOTTOM "\n");
1923

1924
    exit(exitcode);
1925 1926
}

1927 1928 1929 1930 1931 1932
#define HAS_ARG 0x0001

typedef struct QEMUOption {
    const char *name;
    int flags;
    int index;
1933
    uint32_t arch_mask;
1934 1935
} QEMUOption;

B
blueswir1 已提交
1936
static const QEMUOption qemu_options[] = {
1937
    { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
1938 1939
#define QEMU_OPTIONS_GENERATE_OPTIONS
#include "qemu-options-wrapper.h"
1940
    { NULL },
B
bellard 已提交
1941
};
B
Blue Swirl 已提交
1942

1943 1944 1945
typedef struct VGAInterfaceInfo {
    const char *opt_name;    /* option name */
    const char *name;        /* human-readable name */
1946 1947 1948
    /* Class names indicating that support is available.
     * If no class is specified, the interface is always available */
    const char *class_names[2];
1949 1950 1951 1952 1953 1954 1955 1956 1957
} VGAInterfaceInfo;

static VGAInterfaceInfo vga_interfaces[VGA_TYPE_MAX] = {
    [VGA_NONE] = {
        .opt_name = "none",
    },
    [VGA_STD] = {
        .opt_name = "std",
        .name = "standard VGA",
1958
        .class_names = { "VGA", "isa-vga" },
1959 1960 1961 1962
    },
    [VGA_CIRRUS] = {
        .opt_name = "cirrus",
        .name = "Cirrus VGA",
1963
        .class_names = { "cirrus-vga", "isa-cirrus-vga" },
1964 1965 1966 1967
    },
    [VGA_VMWARE] = {
        .opt_name = "vmware",
        .name = "VMWare SVGA",
1968
        .class_names = { "vmware-svga" },
1969 1970 1971 1972
    },
    [VGA_VIRTIO] = {
        .opt_name = "virtio",
        .name = "Virtio VGA",
1973
        .class_names = { "virtio-vga" },
1974 1975 1976 1977
    },
    [VGA_QXL] = {
        .opt_name = "qxl",
        .name = "QXL VGA",
1978
        .class_names = { "qxl-vga" },
1979 1980 1981 1982
    },
    [VGA_TCX] = {
        .opt_name = "tcx",
        .name = "TCX framebuffer",
1983
        .class_names = { "SUNW,tcx" },
1984 1985 1986 1987
    },
    [VGA_CG3] = {
        .opt_name = "cg3",
        .name = "CG3 framebuffer",
1988
        .class_names = { "cgthree" },
1989 1990 1991 1992 1993 1994
    },
    [VGA_XENFB] = {
        .opt_name = "xenfb",
    },
};

1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
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]);
}

2005
static void select_vgahw(const char *p)
2006 2007
{
    const char *opts;
2008
    int t;
2009

2010
    assert(vga_interface_type == VGA_NONE);
2011 2012 2013
    for (t = 0; t < VGA_TYPE_MAX; t++) {
        VGAInterfaceInfo *ti = &vga_interfaces[t];
        if (ti->opt_name && strstart(p, ti->opt_name, &opts)) {
2014
            if (!vga_interface_available(t)) {
2015 2016 2017 2018 2019
                error_report("%s not available", ti->name);
                exit(1);
            }
            vga_interface_type = t;
            break;
2020
        }
2021 2022
    }
    if (t == VGA_TYPE_MAX) {
2023
    invalid_vga:
2024
        error_report("unknown vga type: %s", p);
2025 2026
        exit(1);
    }
2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
    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;
    }
2040 2041
}

2042 2043 2044 2045 2046
static void parse_display_qapi(const char *optarg)
{
    DisplayOptions *opts;
    Visitor *v;

2047
    v = qobject_input_visitor_new_str(optarg, "type", &error_fatal);
2048 2049 2050 2051 2052 2053 2054 2055

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

    qapi_free_DisplayOptions(opts);
    visit_free(v);
}

2056 2057 2058 2059 2060
DisplayOptions *qmp_query_display_options(Error **errp)
{
    return QAPI_CLONE(DisplayOptions, &dpy);
}

2061
static void parse_display(const char *p)
2062 2063 2064 2065
{
    const char *opts;

    if (strstart(p, "sdl", &opts)) {
2066 2067 2068 2069 2070 2071 2072 2073 2074 2075
        /*
         * 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 已提交
2076
        dpy.type = DISPLAY_TYPE_SDL;
2077 2078 2079 2080
        while (*opts) {
            const char *nextopt;

            if (strstart(opts, ",frame=", &nextopt)) {
G
Gerd Hoffmann 已提交
2081 2082
                g_printerr("The frame= sdl option is deprecated, and will be\n"
                           "removed in a future release.\n");
2083 2084 2085 2086 2087 2088
                opts = nextopt;
                if (strstart(opts, "on", &nextopt)) {
                    no_frame = 0;
                } else if (strstart(opts, "off", &nextopt)) {
                    no_frame = 1;
                } else {
2089
                    goto invalid_sdl_args;
2090 2091 2092 2093 2094 2095 2096 2097
                }
            } 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 {
2098
                    goto invalid_sdl_args;
2099 2100 2101 2102 2103 2104 2105 2106
                }
            } 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 {
2107
                    goto invalid_sdl_args;
2108 2109 2110
                }
            } else if (strstart(opts, ",window_close=", &nextopt)) {
                opts = nextopt;
G
Gerd Hoffmann 已提交
2111
                dpy.has_window_close = true;
2112
                if (strstart(opts, "on", &nextopt)) {
G
Gerd Hoffmann 已提交
2113
                    dpy.window_close = true;
2114
                } else if (strstart(opts, "off", &nextopt)) {
G
Gerd Hoffmann 已提交
2115
                    dpy.window_close = false;
2116
                } else {
2117
                    goto invalid_sdl_args;
2118
                }
2119 2120
            } else if (strstart(opts, ",gl=", &nextopt)) {
                opts = nextopt;
G
Gerd Hoffmann 已提交
2121
                dpy.has_gl = true;
2122
                if (strstart(opts, "on", &nextopt)) {
2123
                    dpy.gl = DISPLAYGL_MODE_ON;
2124 2125 2126 2127
                } else if (strstart(opts, "core", &nextopt)) {
                    dpy.gl = DISPLAYGL_MODE_CORE;
                } else if (strstart(opts, "es", &nextopt)) {
                    dpy.gl = DISPLAYGL_MODE_ES;
2128
                } else if (strstart(opts, "off", &nextopt)) {
2129
                    dpy.gl = DISPLAYGL_MODE_OFF;
2130 2131 2132
                } else {
                    goto invalid_sdl_args;
                }
2133
            } else {
2134
            invalid_sdl_args:
2135
                error_report("invalid SDL option string");
2136
                exit(1);
2137 2138 2139
            }
            opts = nextopt;
        }
2140
    } else if (strstart(p, "vnc", &opts)) {
2141 2142 2143 2144
        /*
         * vnc isn't a (local) DisplayType but a protocol for remote
         * display access.
         */
2145
        if (*opts == '=') {
2146
            vnc_parse(opts + 1, &error_fatal);
2147
        } else {
2148
            error_report("VNC requires a display argument vnc=<display>");
2149 2150
            exit(1);
        }
2151
    } else {
2152
        parse_display_qapi(p);
2153 2154 2155
    }
}

P
Paul Brook 已提交
2156 2157
char *qemu_find_file(int type, const char *name)
{
2158
    int i;
P
Paul Brook 已提交
2159 2160 2161
    const char *subdir;
    char *buf;

2162 2163
    /* Try the name as a straight path first */
    if (access(name, R_OK) == 0) {
2164
        trace_load_file(name, name);
2165
        return g_strdup(name);
P
Paul Brook 已提交
2166
    }
2167

P
Paul Brook 已提交
2168 2169 2170 2171 2172 2173 2174 2175 2176 2177
    switch (type) {
    case QEMU_FILE_TYPE_BIOS:
        subdir = "";
        break;
    case QEMU_FILE_TYPE_KEYMAP:
        subdir = "keymaps/";
        break;
    default:
        abort();
    }
2178 2179 2180 2181 2182 2183 2184

    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;
        }
2185
        g_free(buf);
P
Paul Brook 已提交
2186
    }
2187
    return NULL;
P
Paul Brook 已提交
2188 2189
}

G
Gerd Hoffmann 已提交
2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204
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 */
        }
    }
2205
    data_dir[data_dir_idx++] = g_strdup(path);
G
Gerd Hoffmann 已提交
2206 2207
}

2208 2209 2210 2211 2212
static inline bool nonempty_str(const char *str)
{
    return str && *str;
}

2213 2214 2215 2216
static int parse_fw_cfg(void *opaque, QemuOpts *opts, Error **errp)
{
    gchar *buf;
    size_t size;
2217
    const char *name, *file, *str;
2218
    FWCfgState *fw_cfg = (FWCfgState *) opaque;
2219

2220
    if (fw_cfg == NULL) {
2221
        error_setg(errp, "fw_cfg device not available");
2222 2223 2224 2225
        return -1;
    }
    name = qemu_opt_get(opts, "name");
    file = qemu_opt_get(opts, "file");
2226 2227 2228 2229
    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)))) {
2230
        error_setg(errp, "invalid argument(s)");
2231 2232 2233
        return -1;
    }
    if (nonempty_str(file) && nonempty_str(str)) {
2234
        error_setg(errp, "file and string are mutually exclusive");
2235 2236 2237
        return -1;
    }
    if (strlen(name) > FW_CFG_MAX_FILE_PATH - 1) {
2238 2239
        error_setg(errp, "name too long (max. %d char)",
                   FW_CFG_MAX_FILE_PATH - 1);
2240 2241 2242
        return -1;
    }
    if (strncmp(name, "opt/", 4) != 0) {
2243 2244
        warn_report("externally provided fw_cfg item names "
                    "should be prefixed with \"opt/\"");
2245
    }
2246 2247 2248 2249
    if (nonempty_str(str)) {
        size = strlen(str); /* NUL terminator NOT included in fw_cfg blob */
        buf = g_memdup(str, size);
    } else {
2250 2251 2252 2253
        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);
2254 2255
            return -1;
        }
2256
    }
2257 2258 2259 2260
    /* 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);
2261 2262 2263
    return 0;
}

2264
static int device_help_func(void *opaque, QemuOpts *opts, Error **errp)
2265 2266 2267 2268
{
    return qdev_device_help(opts);
}

2269
static int device_init_func(void *opaque, QemuOpts *opts, Error **errp)
2270 2271 2272
{
    DeviceState *dev;

2273
    dev = qdev_device_add(opts, errp);
2274
    if (!dev) {
2275
        return -1;
2276
    }
2277
    object_unref(OBJECT(dev));
2278 2279 2280
    return 0;
}

2281
static int chardev_init_func(void *opaque, QemuOpts *opts, Error **errp)
2282
{
2283
    Error *local_err = NULL;
2284

2285 2286
    if (!qemu_chr_new_from_opts(opts, &local_err)) {
        if (local_err) {
2287
            error_propagate(errp, local_err);
2288 2289 2290
            return -1;
        }
        exit(0);
2291
    }
2292 2293 2294
    return 0;
}

2295
#ifdef CONFIG_VIRTFS
2296
static int fsdev_init_func(void *opaque, QemuOpts *opts, Error **errp)
2297
{
2298
    return qemu_fsdev_add(opts, errp);
2299 2300 2301
}
#endif

2302
static int mon_init_func(void *opaque, QemuOpts *opts, Error **errp)
2303
{
2304
    Chardev *chr;
2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317
    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 {
2318 2319
        error_setg(errp, "unknown monitor mode \"%s\"", mode);
        return -1;
2320 2321
    }

2322 2323 2324
    if (qemu_opt_get_bool(opts, "pretty", 0))
        flags |= MONITOR_USE_PRETTY;

2325 2326 2327 2328 2329
    /* OOB is off by default */
    if (qemu_opt_get_bool(opts, "x-oob", 0)) {
        flags |= MONITOR_USE_OOB;
    }

2330
    chardev = qemu_opt_get(opts, "chardev");
2331 2332 2333 2334
    if (!chardev) {
        error_report("chardev is required");
        exit(1);
    }
2335 2336
    chr = qemu_chr_find(chardev);
    if (chr == NULL) {
2337 2338
        error_setg(errp, "chardev \"%s\" not found", chardev);
        return -1;
2339 2340 2341 2342 2343 2344
    }

    monitor_init(chr, flags);
    return 0;
}

M
Max Reitz 已提交
2345
static void monitor_parse(const char *optarg, const char *mode, bool pretty)
2346 2347 2348 2349 2350 2351 2352 2353 2354
{
    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 {
2355 2356
        snprintf(label, sizeof(label), "compat_monitor%d",
                 monitor_device_index);
2357
        opts = qemu_chr_parse_compat(label, optarg, true);
2358
        if (!opts) {
2359
            error_report("parse error: %s", optarg);
2360 2361 2362 2363
            exit(1);
        }
    }

2364
    opts = qemu_opts_create(qemu_find_opts("mon"), label, 1, &error_fatal);
2365 2366
    qemu_opt_set(opts, "mode", mode, &error_abort);
    qemu_opt_set(opts, "chardev", label, &error_abort);
2367
    qemu_opt_set_bool(opts, "pretty", pretty, &error_abort);
2368 2369 2370
    monitor_device_index++;
}

2371 2372
struct device_config {
    enum {
2373 2374 2375 2376 2377
        DEV_USB,       /* -usbdevice     */
        DEV_BT,        /* -bt            */
        DEV_SERIAL,    /* -serial        */
        DEV_PARALLEL,  /* -parallel      */
        DEV_VIRTCON,   /* -virtioconsole */
2378
        DEV_DEBUGCON,  /* -debugcon */
2379
        DEV_GDB,       /* -gdb, -s */
2380
        DEV_SCLP,      /* s390 sclp */
2381 2382
    } type;
    const char *cmdline;
2383
    Location loc;
2384
    QTAILQ_ENTRY(device_config) next;
2385
};
B
Blue Swirl 已提交
2386 2387 2388

static QTAILQ_HEAD(, device_config) device_configs =
    QTAILQ_HEAD_INITIALIZER(device_configs);
2389 2390 2391 2392 2393

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

2394
    conf = g_malloc0(sizeof(*conf));
2395 2396
    conf->type = type;
    conf->cmdline = cmdline;
2397
    loc_save(&conf->loc);
2398
    QTAILQ_INSERT_TAIL(&device_configs, conf, next);
2399 2400 2401 2402 2403 2404 2405
}

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

2406
    QTAILQ_FOREACH(conf, &device_configs, next) {
2407 2408
        if (conf->type != type)
            continue;
2409
        loc_push_restore(&conf->loc);
2410
        rc = func(conf->cmdline);
2411
        loc_pop(&conf->loc);
G
Gonglei 已提交
2412
        if (rc) {
2413
            return rc;
G
Gonglei 已提交
2414
        }
2415 2416 2417 2418
    }
    return 0;
}

2419 2420
static int serial_parse(const char *devname)
{
2421
    int index = num_serial_hds;
2422 2423 2424 2425 2426
    char label[32];

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

2429
    serial_hds[index] = qemu_chr_new_mux_mon(label, devname);
2430
    if (!serial_hds[index]) {
2431 2432
        error_report("could not connect serial device"
                     " to character backend '%s'", devname);
2433 2434
        return -1;
    }
2435
    num_serial_hds++;
2436 2437 2438
    return 0;
}

2439 2440 2441
Chardev *serial_hd(int i)
{
    assert(i >= 0);
2442
    if (i < num_serial_hds) {
2443 2444 2445 2446 2447
        return serial_hds[i];
    }
    return NULL;
}

2448 2449 2450 2451 2452
int serial_max_hds(void)
{
    return num_serial_hds;
}

2453 2454 2455 2456 2457 2458 2459 2460
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) {
2461
        error_report("too many parallel ports");
2462 2463 2464
        exit(1);
    }
    snprintf(label, sizeof(label), "parallel%d", index);
2465
    parallel_hds[index] = qemu_chr_new_mux_mon(label, devname);
2466
    if (!parallel_hds[index]) {
2467 2468
        error_report("could not connect parallel device"
                     " to character backend '%s'", devname);
2469 2470 2471 2472 2473 2474
        return -1;
    }
    index++;
    return 0;
}

2475 2476
static int virtcon_parse(const char *devname)
{
2477
    QemuOptsList *device = qemu_find_opts("device");
2478 2479
    static int index = 0;
    char label[32];
2480
    QemuOpts *bus_opts, *dev_opts;
2481 2482 2483 2484

    if (strcmp(devname, "none") == 0)
        return 0;
    if (index == MAX_VIRTIO_CONSOLES) {
2485
        error_report("too many virtio consoles");
2486 2487
        exit(1);
    }
2488

2489
    bus_opts = qemu_opts_create(device, NULL, 0, &error_abort);
2490
    qemu_opt_set(bus_opts, "driver", "virtio-serial", &error_abort);
2491

2492
    dev_opts = qemu_opts_create(device, NULL, 0, &error_abort);
2493
    qemu_opt_set(dev_opts, "driver", "virtconsole", &error_abort);
2494

2495
    snprintf(label, sizeof(label), "virtcon%d", index);
2496
    virtcon_hds[index] = qemu_chr_new_mux_mon(label, devname);
2497
    if (!virtcon_hds[index]) {
2498 2499
        error_report("could not connect virtio console"
                     " to character backend '%s'", devname);
2500 2501
        return -1;
    }
2502
    qemu_opt_set(dev_opts, "chardev", label, &error_abort);
2503

2504 2505 2506 2507
    index++;
    return 0;
}

2508
static int debugcon_parse(const char *devname)
L
Laszlo Ersek 已提交
2509
{
2510 2511
    QemuOpts *opts;

2512
    if (!qemu_chr_new_mux_mon("debugcon", devname)) {
2513
        error_report("invalid character backend '%s'", devname);
2514 2515
        exit(1);
    }
2516
    opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL);
2517
    if (!opts) {
2518
        error_report("already have a debugcon device");
2519 2520
        exit(1);
    }
2521 2522
    qemu_opt_set(opts, "driver", "isa-debugcon", &error_abort);
    qemu_opt_set(opts, "chardev", "debugcon", &error_abort);
2523 2524 2525
    return 0;
}

2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
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)
2561
{
2562
    MachineClass *mc = NULL;
2563
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
2564 2565

    if (name) {
2566
        mc = find_machine(name);
2567
    }
2568
    if (mc) {
2569
        g_slist_free(machines);
2570
        return mc;
2571
    }
2572
    if (name && !is_help_option(name)) {
2573
        error_report("unsupported machine type");
2574
        error_printf("Use -machine help to list supported machines\n");
2575 2576
    } else {
        printf("Supported machines are:\n");
2577
        machines = g_slist_sort(machines, machine_class_cmp);
2578 2579
        for (el = machines; el; el = el->next) {
            MachineClass *mc = el->data;
2580 2581
            if (mc->alias) {
                printf("%-20s %s (alias of %s)\n", mc->alias, mc->desc, mc->name);
2582
            }
2583 2584 2585
            printf("%-20s %s%s%s\n", mc->name, mc->desc,
                   mc->is_default ? " (default)" : "",
                   mc->deprecation_reason ? " (deprecated)" : "");
2586 2587
        }
    }
2588 2589

    g_slist_free(machines);
2590
    exit(!name || !is_help_option(name));
2591 2592
}

G
Gerd Hoffmann 已提交
2593 2594 2595 2596 2597 2598 2599
void qemu_add_exit_notifier(Notifier *notify)
{
    notifier_list_add(&exit_notifiers, notify);
}

void qemu_remove_exit_notifier(Notifier *notify)
{
P
Paolo Bonzini 已提交
2600
    notifier_remove(notify);
G
Gerd Hoffmann 已提交
2601 2602 2603 2604
}

static void qemu_run_exit_notifiers(void)
{
2605
    notifier_list_notify(&exit_notifiers, NULL);
G
Gerd Hoffmann 已提交
2606 2607
}

2608 2609 2610 2611 2612 2613 2614 2615 2616 2617
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 已提交
2618
bool machine_init_done;
2619

2620 2621 2622
void qemu_add_machine_init_done_notifier(Notifier *notify)
{
    notifier_list_add(&machine_init_done_notifiers, notify);
2623 2624 2625
    if (machine_init_done) {
        notify->notify(notify, NULL);
    }
2626 2627
}

2628 2629 2630 2631 2632
void qemu_remove_machine_init_done_notifier(Notifier *notify)
{
    notifier_remove(notify);
}

2633 2634
static void qemu_run_machine_init_done_notifiers(void)
{
2635
    machine_init_done = true;
P
Peter Xu 已提交
2636
    notifier_list_notify(&machine_init_done_notifiers, NULL);
2637 2638
}

2639 2640 2641 2642 2643 2644 2645 2646
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;

2647
    loc_set_cmdline(argv, optind, 1);
2648 2649 2650 2651 2652 2653 2654
    optind++;
    /* Treat --foo the same as -foo.  */
    if (r[1] == '-')
        r++;
    popt = qemu_options;
    for(;;) {
        if (!popt->name) {
2655
            error_report("invalid option");
2656 2657 2658 2659 2660 2661 2662 2663
            exit(1);
        }
        if (!strcmp(popt->name, r + 1))
            break;
        popt++;
    }
    if (popt->flags & HAS_ARG) {
        if (optind >= argc) {
2664
            error_report("requires an argument");
2665 2666 2667
            exit(1);
        }
        optarg = argv[optind++];
2668
        loc_set_cmdline(argv, optind - 2, 2);
2669 2670 2671 2672 2673 2674 2675 2676 2677 2678
    } else {
        optarg = NULL;
    }

    *poptarg = optarg;
    *poptind = optind;

    return popt;
}

2679
static MachineClass *select_machine(void)
2680
{
2681
    MachineClass *machine_class = find_default_machine();
2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692
    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) {
2693
        machine_class = machine_parse(optarg);
2694 2695
    }

2696
    if (!machine_class) {
2697 2698 2699 2700 2701 2702
        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);
2703
    return machine_class;
2704 2705
}

2706 2707 2708
static int machine_set_property(void *opaque,
                                const char *name, const char *value,
                                Error **errp)
2709 2710 2711
{
    Object *obj = OBJECT(opaque);
    Error *local_err = NULL;
2712
    char *p, *qom_name;
2713

2714
    if (strcmp(name, "type") == 0) {
2715 2716 2717
        return 0;
    }

2718
    qom_name = g_strdup(name);
2719 2720 2721
    for (p = qom_name; *p; p++) {
        if (*p == '_') {
            *p = '-';
2722 2723 2724
        }
    }

2725
    object_property_parse(obj, value, qom_name, &local_err);
2726
    g_free(qom_name);
2727 2728

    if (local_err) {
2729
        error_propagate(errp, local_err);
2730 2731 2732 2733 2734 2735
        return -1;
    }

    return 0;
}

2736 2737 2738 2739 2740 2741 2742 2743

/*
 * 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.
 */
2744
static bool object_create_initial(const char *type, QemuOpts *opts)
2745
{
2746 2747
    ObjectClass *klass;

2748 2749 2750 2751 2752 2753 2754
    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);
2755
            printf("  %s\n", object_class_get_name(oc));
2756 2757 2758 2759 2760
        }
        g_slist_free(list);
        exit(0);
    }

2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776
    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);
2777
            g_string_append_printf(str, "  %s=<%s>", prop->name, prop->type);
2778
            if (prop->description) {
2779 2780 2781
                if (str->len < 24) {
                    g_string_append_printf(str, "%*s", 24 - (int)str->len, "");
                }
2782 2783 2784 2785 2786
                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);
2787 2788 2789 2790 2791
        if (array->len > 0) {
            printf("%s options:\n", type);
        } else {
            printf("There are no options for %s.\n", type);
        }
2792 2793 2794 2795 2796 2797 2798 2799
        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);
    }

2800 2801
    if (g_str_equal(type, "rng-egd") ||
        g_str_has_prefix(type, "pr-manager-")) {
2802 2803
        return false;
    }
2804

2805 2806 2807 2808 2809 2810
#if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
    if (g_str_equal(type, "cryptodev-vhost-user")) {
        return false;
    }
#endif

2811 2812 2813 2814 2815
    /*
     * return false for concrete netfilters since
     * they depend on netdevs already existing
     */
    if (g_str_equal(type, "filter-buffer") ||
2816
        g_str_equal(type, "filter-dump") ||
2817
        g_str_equal(type, "filter-mirror") ||
2818
        g_str_equal(type, "filter-redirector") ||
2819
        g_str_equal(type, "colo-compare") ||
2820 2821
        g_str_equal(type, "filter-rewriter") ||
        g_str_equal(type, "filter-replay")) {
2822 2823 2824
        return false;
    }

2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837
    /* 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;
    }

2838 2839 2840 2841 2842 2843
    return true;
}


/*
 * The remainder of object creation happens after the
2844
 * creation of chardev, fsdev, net clients and device data types.
2845
 */
2846
static bool object_create_delayed(const char *type, QemuOpts *opts)
2847
{
2848
    return !object_create_initial(type, opts);
2849 2850 2851
}


2852 2853
static void set_memory_options(uint64_t *ram_slots, ram_addr_t *maxram_size,
                               MachineClass *mc)
2854 2855 2856
{
    uint64_t sz;
    const char *mem_str;
2857
    const ram_addr_t default_ram_size = mc->default_ram_size;
2858
    QemuOpts *opts = qemu_find_opts_singleton("memory");
2859 2860 2861 2862
    Location loc;

    loc_push_none(&loc);
    qemu_opts_loc_restore(opts);
2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877

    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;

2878 2879
            sz *= MiB;
            if (sz / MiB != overflow_check) {
2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898
                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 */
2899
    qemu_opt_set_number(opts, "size", ram_size, &error_abort);
2900 2901
    *maxram_size = ram_size;

2902
    if (qemu_opt_get(opts, "maxmem")) {
2903 2904 2905
        uint64_t slots;

        sz = qemu_opt_get_size(opts, "maxmem", 0);
2906
        slots = qemu_opt_get_number(opts, "slots", 0);
2907
        if (sz < ram_size) {
2908 2909 2910 2911
            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);
2912
            exit(EXIT_FAILURE);
2913
        } else if (slots && sz == ram_size) {
2914 2915 2916 2917
            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);
2918 2919 2920 2921 2922
            exit(EXIT_FAILURE);
        }

        *maxram_size = sz;
        *ram_slots = slots;
2923 2924
    } else if (qemu_opt_get(opts, "slots")) {
        error_report("invalid -m option value: missing 'maxmem' option");
2925 2926
        exit(EXIT_FAILURE);
    }
2927 2928

    loc_pop(&loc);
2929 2930
}

2931 2932 2933 2934 2935 2936 2937 2938 2939
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;
2940
    g->errp = &error_fatal;
2941 2942 2943 2944
    qdev_prop_register_global(g);
    return 0;
}

2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956
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;
}

2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975
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 已提交
2976
int main(int argc, char **argv, char **envp)
2977
{
2978
    int i;
2979
    int snapshot, linux_boot;
2980
    const char *initrd_filename;
2981
    const char *kernel_filename, *kernel_cmdline;
2982 2983
    const char *boot_order = NULL;
    const char *boot_once = NULL;
2984
    DisplayState *ds;
2985
    QemuOpts *opts, *machine_opts;
2986
    QemuOpts *icount_opts = NULL, *accel_opts = NULL;
2987
    QemuOptsList *olist;
2988
    int optind;
2989
    const char *optarg;
2990
    const char *loadvm = NULL;
2991
    MachineClass *machine_class;
2992
    const char *cpu_model;
2993
    const char *vga_model = NULL;
2994 2995
    const char *qtest_chrdev = NULL;
    const char *qtest_log = NULL;
2996
    const char *incoming = NULL;
2997
    bool userconfig = true;
2998
    bool nographic = false;
2999
    int display_remote = 0;
3000 3001
    const char *log_mask = NULL;
    const char *log_file = NULL;
3002
    char *trace_file = NULL;
3003
    ram_addr_t maxram_size;
3004
    uint64_t ram_slots = 0;
3005
    FILE *vmstate_dump_file = NULL;
3006
    Error *main_loop_err = NULL;
3007
    Error *err = NULL;
3008
    bool list_data_dirs = false;
3009
    char *dir, **dirs;
3010 3011 3012 3013 3014 3015 3016
    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);
3017

3018 3019
    module_call_init(MODULE_INIT_TRACE);

3020
    qemu_init_cpu_list();
3021
    qemu_init_cpu_loop();
3022

3023 3024
    qemu_mutex_lock_iothread();

G
Gerd Hoffmann 已提交
3025
    atexit(qemu_run_exit_notifiers);
3026
    error_set_progname(argv[0]);
3027
    qemu_init_exec_dir(argv[0]);
3028

3029 3030
    module_call_init(MODULE_INIT_QOM);

3031
    qemu_add_opts(&qemu_drive_opts);
3032 3033 3034
    qemu_add_drive_opts(&qemu_legacy_drive_opts);
    qemu_add_drive_opts(&qemu_common_drive_opts);
    qemu_add_drive_opts(&qemu_drive_opts);
3035
    qemu_add_drive_opts(&bdrv_runtime_opts);
3036 3037 3038
    qemu_add_opts(&qemu_chardev_opts);
    qemu_add_opts(&qemu_device_opts);
    qemu_add_opts(&qemu_netdev_opts);
3039
    qemu_add_opts(&qemu_nic_opts);
3040 3041 3042 3043 3044 3045 3046
    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);
3047
    qemu_add_opts(&qemu_accel_opts);
3048
    qemu_add_opts(&qemu_mem_opts);
3049
    qemu_add_opts(&qemu_smp_opts);
3050 3051 3052
    qemu_add_opts(&qemu_boot_opts);
    qemu_add_opts(&qemu_add_fd_opts);
    qemu_add_opts(&qemu_object_opts);
3053
    qemu_add_opts(&qemu_tpmdev_opts);
3054
    qemu_add_opts(&qemu_realtime_opts);
3055
    qemu_add_opts(&qemu_overcommit_opts);
3056
    qemu_add_opts(&qemu_msg_opts);
3057
    qemu_add_opts(&qemu_name_opts);
3058
    qemu_add_opts(&qemu_numa_opts);
3059
    qemu_add_opts(&qemu_icount_opts);
3060
    qemu_add_opts(&qemu_semihosting_config_opts);
3061
    qemu_add_opts(&qemu_fw_cfg_opts);
3062
    module_call_init(MODULE_INIT_OPTS);
3063

3064
    runstate_init();
3065
    postcopy_infrastructure_init();
3066
    monitor_init_globals();
3067

3068
    if (qcrypto_init(&err) < 0) {
3069
        error_reportf_err(err, "cannot initialize crypto: ");
3070 3071
        exit(1);
    }
J
Jan Kiszka 已提交
3072

3073
    QLIST_INIT (&vm_change_state_head);
3074
    os_setup_early_signal_handling();
3075

3076
    cpu_model = NULL;
3077
    snapshot = 0;
3078

B
bellard 已提交
3079
    nb_nics = 0;
3080

3081 3082
    bdrv_init_with_whitelist();

3083
    autostart = 1;
3084

3085 3086 3087 3088 3089
    /* first pass of option parsing */
    optind = 1;
    while (optind < argc) {
        if (argv[optind][0] != '-') {
            /* disk image */
3090
            optind++;
3091 3092 3093 3094 3095
        } else {
            const QEMUOption *popt;

            popt = lookup_opt(argc, argv, &optarg, &optind);
            switch (popt->index) {
3096 3097 3098
            case QEMU_OPTION_nouserconfig:
                userconfig = false;
                break;
3099 3100 3101 3102
            }
        }
    }

3103
    if (userconfig) {
3104
        if (qemu_read_default_config_file() < 0) {
3105
            exit(1);
3106 3107 3108 3109
        }
    }

    /* second pass of option parsing */
3110
    optind = 1;
3111
    for(;;) {
3112
        if (optind >= argc)
3113
            break;
3114
        if (argv[optind][0] != '-') {
3115
            drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
3116 3117 3118
        } else {
            const QEMUOption *popt;

3119
            popt = lookup_opt(argc, argv, &optarg, &optind);
3120
            if (!(popt->arch_mask & arch_type)) {
3121
                error_report("Option not supported for this target");
3122 3123
                exit(1);
            }
3124
            switch(popt->index) {
3125 3126
            case QEMU_OPTION_cpu:
                /* hw initialization will check this */
3127
                cpu_model = optarg;
3128
                break;
3129 3130
            case QEMU_OPTION_hda:
            case QEMU_OPTION_hdb:
3131 3132
            case QEMU_OPTION_hdc:
            case QEMU_OPTION_hdd:
3133 3134
                drive_add(IF_DEFAULT, popt->index - QEMU_OPTION_hda, optarg,
                          HD_OPTS);
B
bellard 已提交
3135
                break;
3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154
            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;
                }
3155
            case QEMU_OPTION_drive:
3156 3157 3158
                if (drive_def(optarg) == NULL) {
                    exit(1);
                }
3159
                break;
G
Gerd Hoffmann 已提交
3160 3161 3162
            case QEMU_OPTION_set:
                if (qemu_set_option(optarg) != 0)
                    exit(1);
3163
                break;
3164 3165 3166
            case QEMU_OPTION_global:
                if (qemu_global_option(optarg) != 0)
                    exit(1);
3167
                break;
3168
            case QEMU_OPTION_mtdblock:
3169
                drive_add(IF_MTD, -1, optarg, MTD_OPTS);
3170
                break;
3171
            case QEMU_OPTION_sd:
3172
                drive_add(IF_SD, -1, optarg, SD_OPTS);
3173
                break;
3174
            case QEMU_OPTION_pflash:
3175
                drive_add(IF_PFLASH, -1, optarg, PFLASH_OPTS);
3176
                break;
3177
            case QEMU_OPTION_snapshot:
3178 3179
                snapshot = 1;
                break;
3180
            case QEMU_OPTION_numa:
3181 3182
                opts = qemu_opts_parse_noisily(qemu_find_opts("numa"),
                                               optarg, true);
3183 3184 3185
                if (!opts) {
                    exit(1);
                }
3186
                break;
3187
            case QEMU_OPTION_display:
3188
                parse_display(optarg);
3189
                break;
3190
            case QEMU_OPTION_nographic:
3191 3192 3193
                olist = qemu_find_opts("machine");
                qemu_opts_parse_noisily(olist, "graphics=off", false);
                nographic = true;
3194
                dpy.type = DISPLAY_TYPE_NONE;
3195
                break;
B
balrog 已提交
3196
            case QEMU_OPTION_curses:
3197
#ifdef CONFIG_CURSES
3198
                dpy.type = DISPLAY_TYPE_CURSES;
3199
#else
3200
                error_report("curses support is disabled");
3201
                exit(1);
B
balrog 已提交
3202
#endif
3203
                break;
3204
            case QEMU_OPTION_portrait:
3205 3206 3207 3208 3209 3210
                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) {
3211
                    error_report("only 90, 180, 270 deg rotation is available");
3212 3213
                    exit(1);
                }
3214
                break;
3215
            case QEMU_OPTION_kernel:
3216 3217
                qemu_opts_set(qemu_find_opts("machine"), 0, "kernel", optarg,
                              &error_abort);
3218 3219
                break;
            case QEMU_OPTION_initrd:
3220 3221
                qemu_opts_set(qemu_find_opts("machine"), 0, "initrd", optarg,
                              &error_abort);
3222
                break;
3223
            case QEMU_OPTION_append:
3224 3225
                qemu_opts_set(qemu_find_opts("machine"), 0, "append", optarg,
                              &error_abort);
3226
                break;
3227
            case QEMU_OPTION_dtb:
3228 3229
                qemu_opts_set(qemu_find_opts("machine"), 0, "dtb", optarg,
                              &error_abort);
3230
                break;
3231
            case QEMU_OPTION_cdrom:
3232
                drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS);
3233
                break;
3234
            case QEMU_OPTION_boot:
3235 3236
                opts = qemu_opts_parse_noisily(qemu_find_opts("boot-opts"),
                                               optarg, true);
3237 3238
                if (!opts) {
                    exit(1);
3239 3240
                }
                break;
3241 3242
            case QEMU_OPTION_fda:
            case QEMU_OPTION_fdb:
3243 3244
                drive_add(IF_FLOPPY, popt->index - QEMU_OPTION_fda,
                          optarg, FD_OPTS);
3245
                break;
3246 3247 3248
            case QEMU_OPTION_no_fd_bootchk:
                fd_bootchk = 0;
                break;
M
Mark McLoughlin 已提交
3249
            case QEMU_OPTION_netdev:
3250
                default_net = 0;
3251
                if (net_client_parse(qemu_find_opts("netdev"), optarg) == -1) {
M
Mark McLoughlin 已提交
3252 3253 3254
                    exit(1);
                }
                break;
3255 3256 3257 3258 3259 3260
            case QEMU_OPTION_nic:
                default_net = 0;
                if (net_client_parse(qemu_find_opts("nic"), optarg) == -1) {
                    exit(1);
                }
                break;
B
bellard 已提交
3261
            case QEMU_OPTION_net:
3262
                default_net = 0;
3263
                if (net_client_parse(qemu_find_opts("net"), optarg) == -1) {
3264 3265
                    exit(1);
                }
B
bellard 已提交
3266
                break;
3267 3268
#ifdef CONFIG_LIBISCSI
            case QEMU_OPTION_iscsi:
3269 3270
                opts = qemu_opts_parse_noisily(qemu_find_opts("iscsi"),
                                               optarg, false);
3271 3272 3273 3274
                if (!opts) {
                    exit(1);
                }
                break;
B
bellard 已提交
3275
#endif
3276
            case QEMU_OPTION_bt:
3277 3278 3279 3280
                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.");
3281
                add_device_config(DEV_BT, optarg);
3282
                break;
3283 3284 3285 3286 3287 3288 3289
            case QEMU_OPTION_audio_help:
                AUD_help ();
                exit (0);
                break;
            case QEMU_OPTION_soundhw:
                select_soundhw (optarg);
                break;
3290
            case QEMU_OPTION_h:
3291
                help(0);
3292
                break;
P
pbrook 已提交
3293 3294 3295 3296
            case QEMU_OPTION_version:
                version();
                exit(0);
                break;
3297
            case QEMU_OPTION_m:
3298 3299
                opts = qemu_opts_parse_noisily(qemu_find_opts("memory"),
                                               optarg, true);
3300 3301 3302
                if (!opts) {
                    exit(EXIT_FAILURE);
                }
3303
                break;
3304 3305 3306 3307 3308 3309 3310
#ifdef CONFIG_TPM
            case QEMU_OPTION_tpmdev:
                if (tpm_config_parse(qemu_find_opts("tpmdev"), optarg) < 0) {
                    exit(1);
                }
                break;
#endif
3311 3312 3313 3314 3315 3316
            case QEMU_OPTION_mempath:
                mem_path = optarg;
                break;
            case QEMU_OPTION_mem_prealloc:
                mem_prealloc = 1;
                break;
3317
            case QEMU_OPTION_d:
3318 3319 3320 3321
                log_mask = optarg;
                break;
            case QEMU_OPTION_D:
                log_file = optarg;
3322
                break;
3323
            case QEMU_OPTION_DFILTER:
3324
                qemu_set_dfilter_ranges(optarg, &error_fatal);
3325
                break;
3326
            case QEMU_OPTION_s:
3327
                add_device_config(DEV_GDB, "tcp::" DEFAULT_GDBSTUB_PORT);
3328
                break;
3329
            case QEMU_OPTION_gdb:
3330
                add_device_config(DEV_GDB, optarg);
3331 3332
                break;
            case QEMU_OPTION_L:
3333 3334
                if (is_help_option(optarg)) {
                    list_data_dirs = true;
G
Gerd Hoffmann 已提交
3335 3336
                } else {
                    qemu_add_data_dir(optarg);
3337
                }
3338
                break;
3339
            case QEMU_OPTION_bios:
3340 3341
                qemu_opts_set(qemu_find_opts("machine"), 0, "firmware", optarg,
                              &error_abort);
3342
                break;
3343 3344 3345
            case QEMU_OPTION_singlestep:
                singlestep = 1;
                break;
3346
            case QEMU_OPTION_S:
3347
                autostart = 0;
3348
                break;
3349 3350 3351
            case QEMU_OPTION_k:
                keyboard_layout = optarg;
                break;
3352
            case QEMU_OPTION_vga:
B
Blue Swirl 已提交
3353
                vga_model = optarg;
3354
                default_vga = 0;
3355
                break;
3356 3357 3358 3359 3360 3361 3362 3363
            case QEMU_OPTION_g:
                {
                    const char *p;
                    int w, h, depth;
                    p = optarg;
                    w = strtol(p, (char **)&p, 10);
                    if (w <= 0) {
                    graphic_error:
3364
                        error_report("invalid resolution or depth");
3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375
                        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);
3376
                        if (depth != 8 && depth != 15 && depth != 16 &&
3377 3378 3379 3380 3381 3382 3383
                            depth != 24 && depth != 32)
                            goto graphic_error;
                    } else if (*p == '\0') {
                        depth = graphic_depth;
                    } else {
                        goto graphic_error;
                    }
3384

3385 3386 3387 3388 3389
                    graphic_width = w;
                    graphic_height = h;
                    graphic_depth = depth;
                }
                break;
3390 3391 3392 3393 3394 3395 3396 3397
            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 已提交
3398
            case QEMU_OPTION_monitor:
3399
                default_monitor = 0;
3400
                if (strncmp(optarg, "none", 4)) {
M
Max Reitz 已提交
3401
                    monitor_parse(optarg, "readline", false);
3402
                }
3403 3404
                break;
            case QEMU_OPTION_qmp:
M
Max Reitz 已提交
3405 3406 3407 3408 3409
                monitor_parse(optarg, "control", false);
                default_monitor = 0;
                break;
            case QEMU_OPTION_qmp_pretty:
                monitor_parse(optarg, "control", true);
3410
                default_monitor = 0;
B
bellard 已提交
3411
                break;
G
Gerd Hoffmann 已提交
3412
            case QEMU_OPTION_mon:
3413 3414
                opts = qemu_opts_parse_noisily(qemu_find_opts("mon"), optarg,
                                               true);
G
Gerd Hoffmann 已提交
3415 3416 3417
                if (!opts) {
                    exit(1);
                }
3418
                default_monitor = 0;
G
Gerd Hoffmann 已提交
3419
                break;
3420
            case QEMU_OPTION_chardev:
3421 3422
                opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
                                               optarg, true);
3423 3424 3425 3426
                if (!opts) {
                    exit(1);
                }
                break;
3427
            case QEMU_OPTION_fsdev:
3428 3429
                olist = qemu_find_opts("fsdev");
                if (!olist) {
3430
                    error_report("fsdev support is disabled");
3431 3432
                    exit(1);
                }
3433
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3434 3435 3436 3437
                if (!opts) {
                    exit(1);
                }
                break;
3438
            case QEMU_OPTION_virtfs: {
3439 3440
                QemuOpts *fsdev;
                QemuOpts *device;
3441
                const char *writeout, *sock_fd, *socket, *path, *security_model;
3442

3443 3444
                olist = qemu_find_opts("virtfs");
                if (!olist) {
3445
                    error_report("virtfs support is disabled");
3446 3447
                    exit(1);
                }
3448
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3449 3450 3451 3452
                if (!opts) {
                    exit(1);
                }

3453
                if (qemu_opt_get(opts, "fsdriver") == NULL ||
3454
                    qemu_opt_get(opts, "mount_tag") == NULL) {
3455
                    error_report("Usage: -virtfs fsdriver,mount_tag=tag");
3456 3457
                    exit(1);
                }
3458
                fsdev = qemu_opts_create(qemu_find_opts("fsdev"),
3459
                                         qemu_opts_id(opts) ?:
3460 3461
                                         qemu_opt_get(opts, "mount_tag"),
                                         1, NULL);
3462
                if (!fsdev) {
3463
                    error_report("duplicate or invalid fsdev id: %s",
3464
                                 qemu_opt_get(opts, "mount_tag"));
3465 3466
                    exit(1);
                }
3467 3468 3469 3470

                writeout = qemu_opt_get(opts, "writeout");
                if (writeout) {
#ifdef CONFIG_SYNC_FILE_RANGE
3471
                    qemu_opt_set(fsdev, "writeout", writeout, &error_abort);
3472
#else
3473 3474
                    error_report("writeout=immediate not supported "
                                 "on this platform");
3475 3476 3477
                    exit(1);
#endif
                }
3478 3479
                qemu_opt_set(fsdev, "fsdriver",
                             qemu_opt_get(opts, "fsdriver"), &error_abort);
3480 3481 3482 3483 3484 3485 3486 3487 3488
                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);
                }
3489 3490
                socket = qemu_opt_get(opts, "socket");
                if (socket) {
3491
                    qemu_opt_set(fsdev, "socket", socket, &error_abort);
3492
                }
3493 3494
                sock_fd = qemu_opt_get(opts, "sock_fd");
                if (sock_fd) {
3495
                    qemu_opt_set(fsdev, "sock_fd", sock_fd, &error_abort);
3496
                }
3497

3498
                qemu_opt_set_bool(fsdev, "readonly",
3499 3500
                                  qemu_opt_get_bool(opts, "readonly", 0),
                                  &error_abort);
3501 3502
                device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                          &error_abort);
3503
                qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
3504
                qemu_opt_set(device, "fsdev",
3505
                             qemu_opts_id(fsdev), &error_abort);
3506
                qemu_opt_set(device, "mount_tag",
3507
                             qemu_opt_get(opts, "mount_tag"), &error_abort);
3508 3509
                break;
            }
3510 3511 3512 3513
            case QEMU_OPTION_virtfs_synth: {
                QemuOpts *fsdev;
                QemuOpts *device;

3514 3515
                fsdev = qemu_opts_create(qemu_find_opts("fsdev"), "v_synth",
                                         1, NULL);
3516
                if (!fsdev) {
3517
                    error_report("duplicate option: %s", "virtfs_synth");
3518 3519
                    exit(1);
                }
3520
                qemu_opt_set(fsdev, "fsdriver", "synth", &error_abort);
3521

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

4004 4005
    replay_configure(icount_opts);

4006 4007 4008 4009 4010 4011
    if (incoming && !preconfig_exit_requested) {
        error_report("'preconfig' and 'incoming' options are "
                     "mutually exclusive");
        exit(EXIT_FAILURE);
    }

4012 4013
    configure_rtc(qemu_find_opts_singleton("rtc"));

4014
    machine_class = select_machine();
4015 4016

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

4018
    os_daemonize();
4019
    rcu_disable_atfork();
4020

4021 4022
    if (pid_file && !qemu_write_pidfile(pid_file, &err)) {
        error_reportf_err(err, "cannot create PID file: ");
4023 4024 4025
        exit(1);
    }

4026 4027 4028
    qemu_unlink_pidfile_notifier.notify = qemu_unlink_pidfile;
    qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier);

4029
    if (qemu_init_main_loop(&main_loop_err)) {
4030
        error_report_err(main_loop_err);
4031 4032 4033
        exit(1);
    }

4034
#ifdef CONFIG_SECCOMP
4035
    olist = qemu_find_opts_err("sandbox", NULL);
4036 4037
    if (olist) {
        qemu_opts_foreach(olist, parse_sandbox, NULL, &error_fatal);
4038
    }
4039
#endif
4040

4041 4042
    qemu_opts_foreach(qemu_find_opts("name"),
                      parse_name, NULL, &error_fatal);
4043

4044
#ifndef _WIN32
4045 4046
    qemu_opts_foreach(qemu_find_opts("add-fd"),
                      parse_add_fd, NULL, &error_fatal);
4047

4048 4049
    qemu_opts_foreach(qemu_find_opts("add-fd"),
                      cleanup_add_fd, NULL, &error_fatal);
4050 4051
#endif

4052 4053
    current_machine = MACHINE(object_new(object_class_get_name(
                          OBJECT_CLASS(machine_class))));
4054 4055 4056
    if (machine_help_func(qemu_get_machine_opts(), current_machine)) {
        exit(0);
    }
4057 4058
    object_property_add_child(object_get_root(), "machine",
                              OBJECT(current_machine), &error_abort);
4059 4060 4061 4062 4063 4064 4065 4066 4067 4068

    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();
        }
    }

4069
    cpu_exec_init_all();
4070

4071
    if (machine_class->hw_version) {
4072
        qemu_set_hw_version(machine_class->hw_version);
4073 4074
    }

4075
    if (cpu_model && is_help_option(cpu_model)) {
4076
        list_cpus(stdout, &fprintf, cpu_model);
4077 4078 4079
        exit(0);
    }

4080 4081 4082
    if (!trace_init_backends()) {
        exit(1);
    }
4083 4084
    trace_init_file(trace_file);

4085
    /* Open the logfile at this point and set the log mask if necessary.
4086
     */
4087
    if (log_file) {
4088
        qemu_set_log_filename(log_file, &error_fatal);
4089 4090
    }

4091
    if (log_mask) {
4092 4093 4094 4095 4096 4097 4098
        int mask;
        mask = qemu_str_to_log_mask(log_mask);
        if (!mask) {
            qemu_print_log_usage(stdout);
            exit(1);
        }
        qemu_set_log(mask);
4099 4100
    } else {
        qemu_set_log(0);
4101
    }
4102

4103 4104 4105 4106 4107
    /* 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]);
    }
4108
    g_strfreev(dirs);
4109 4110

    /* try to find datadir relative to the executable path */
4111 4112 4113
    dir = os_find_datadir();
    qemu_add_data_dir(dir);
    g_free(dir);
G
Gerd Hoffmann 已提交
4114

4115
    /* add the datadir specified when building */
G
Gerd Hoffmann 已提交
4116
    qemu_add_data_dir(CONFIG_QEMU_DATADIR);
P
Paul Brook 已提交
4117

4118 4119 4120 4121 4122 4123 4124 4125
    /* -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);
    }

4126 4127 4128 4129 4130 4131 4132 4133 4134
    /* 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;

4135
    smp_parse(qemu_opts_find(qemu_find_opts("smp-opts"), NULL));
4136

4137 4138 4139 4140 4141 4142 4143
    /* 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 已提交
4144
    if (max_cpus > machine_class->max_cpus) {
4145 4146
        error_report("Invalid SMP CPUs %d. The max CPUs "
                     "supported by machine '%s' is %d", max_cpus,
4147
                     machine_class->name, machine_class->max_cpus);
4148 4149 4150
        exit(1);
    }

4151 4152 4153 4154
    /*
     * Get the default machine options from the machine if it is not already
     * specified either by the configuration file or by the command line.
     */
4155
    if (machine_class->default_machine_opts) {
4156
        qemu_opts_set_defaults(qemu_find_opts("machine"),
4157
                               machine_class->default_machine_opts, 0);
4158 4159
    }

4160 4161 4162 4163
    qemu_opts_foreach(qemu_find_opts("device"),
                      default_driver_check, NULL, NULL);
    qemu_opts_foreach(qemu_find_opts("global"),
                      default_driver_check, NULL, NULL);
4164

4165 4166 4167
    if (!vga_model && !default_vga) {
        vga_interface_type = VGA_DEVICE;
    }
4168
    if (!has_defaults || machine_class->no_serial) {
4169 4170
        default_serial = 0;
    }
4171
    if (!has_defaults || machine_class->no_parallel) {
4172 4173
        default_parallel = 0;
    }
4174
    if (!has_defaults || !machine_class->use_virtcon) {
4175 4176
        default_virtcon = 0;
    }
4177
    if (!has_defaults || machine_class->no_floppy) {
4178 4179
        default_floppy = 0;
    }
4180
    if (!has_defaults || machine_class->no_cdrom) {
4181 4182
        default_cdrom = 0;
    }
4183
    if (!has_defaults || machine_class->no_sdcard) {
4184 4185
        default_sdcard = 0;
    }
4186 4187 4188 4189 4190
    if (!has_defaults) {
        default_monitor = 0;
        default_net = 0;
        default_vga = 0;
    }
4191

4192
    if (is_daemonized()) {
4193 4194 4195 4196 4197 4198
        if (!preconfig_exit_requested) {
            error_report("'preconfig' and 'daemonize' options are "
                         "mutually exclusive");
            exit(EXIT_FAILURE);
        }

4199 4200 4201 4202 4203 4204 4205 4206 4207
        /* 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.
         */
4208
        if (nographic
4209 4210
            && (default_parallel || default_serial
                || default_monitor || default_virtcon)) {
4211
            error_report("-nographic cannot be used with -daemonize");
4212 4213 4214
            exit(1);
        }
#ifdef CONFIG_CURSES
4215
        if (dpy.type == DISPLAY_TYPE_CURSES) {
4216
            error_report("curses display cannot be used with -daemonize");
4217 4218 4219 4220 4221
            exit(1);
        }
#endif
    }

4222
    if (nographic) {
4223 4224
        if (default_parallel)
            add_device_config(DEV_PARALLEL, "null");
G
Gerd Hoffmann 已提交
4225 4226
        if (default_serial && default_monitor) {
            add_device_config(DEV_SERIAL, "mon:stdio");
4227 4228
        } else if (default_virtcon && default_monitor) {
            add_device_config(DEV_VIRTCON, "mon:stdio");
G
Gerd Hoffmann 已提交
4229 4230 4231
        } else {
            if (default_serial)
                add_device_config(DEV_SERIAL, "stdio");
4232 4233
            if (default_virtcon)
                add_device_config(DEV_VIRTCON, "stdio");
G
Gerd Hoffmann 已提交
4234
            if (default_monitor)
M
Max Reitz 已提交
4235
                monitor_parse("stdio", "readline", false);
G
Gerd Hoffmann 已提交
4236
        }
4237 4238 4239
    } else {
        if (default_serial)
            add_device_config(DEV_SERIAL, "vc:80Cx24C");
4240 4241
        if (default_parallel)
            add_device_config(DEV_PARALLEL, "vc:80Cx24C");
4242
        if (default_monitor)
M
Max Reitz 已提交
4243
            monitor_parse("vc:80Cx24C", "readline", false);
4244 4245
        if (default_virtcon)
            add_device_config(DEV_VIRTCON, "vc:80Cx24C");
4246 4247
    }

G
Gerd Hoffmann 已提交
4248 4249 4250 4251 4252
#if defined(CONFIG_VNC)
    if (!QTAILQ_EMPTY(&(qemu_find_opts("vnc")->head))) {
        display_remote++;
    }
#endif
4253
    if (dpy.type == DISPLAY_TYPE_DEFAULT && !display_remote) {
4254 4255 4256 4257
        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);
4258
#endif
4259
        }
4260
    }
4261 4262
    if (dpy.type == DISPLAY_TYPE_DEFAULT) {
        dpy.type = DISPLAY_TYPE_NONE;
4263 4264
    }

4265
    if ((no_frame || alt_grab || ctrl_grab) && dpy.type != DISPLAY_TYPE_SDL) {
4266 4267
        error_report("-no-frame, -alt-grab and -ctrl-grab are only valid "
                     "for SDL, ignoring option");
4268
    }
4269
    if (dpy.has_window_close &&
4270
        (dpy.type != DISPLAY_TYPE_GTK && dpy.type != DISPLAY_TYPE_SDL)) {
4271 4272
        error_report("-no-quit is only valid for GTK and SDL, "
                     "ignoring option");
4273 4274
    }

4275
    qemu_display_early_init(&dpy);
M
Marc-André Lureau 已提交
4276 4277
    qemu_console_early_init();

4278
    if (dpy.has_gl && dpy.gl != DISPLAYGL_MODE_OFF && display_opengl == 0) {
4279
#if defined(CONFIG_OPENGL)
4280
        error_report("OpenGL is not supported by the display");
4281
#else
4282
        error_report("OpenGL support is disabled");
4283 4284 4285
#endif
        exit(1);
    }
4286

4287
    page_size_init();
T
TeLeMan 已提交
4288 4289
    socket_init();

4290 4291 4292
    qemu_opts_foreach(qemu_find_opts("object"),
                      user_creatable_add_opts_foreach,
                      object_create_initial, &error_fatal);
4293

4294 4295
    qemu_opts_foreach(qemu_find_opts("chardev"),
                      chardev_init_func, NULL, &error_fatal);
4296

4297
#ifdef CONFIG_VIRTFS
4298 4299
    qemu_opts_foreach(qemu_find_opts("fsdev"),
                      fsdev_init_func, NULL, &error_fatal);
4300
#endif
4301

4302 4303
    if (qemu_opts_foreach(qemu_find_opts("device"),
                          device_help_func, NULL, NULL)) {
4304 4305 4306
        exit(0);
    }

4307
    machine_opts = qemu_get_machine_opts();
4308 4309
    qemu_opt_foreach(machine_opts, machine_set_property, current_machine,
                     &error_fatal);
4310

4311
    configure_accelerator(current_machine);
M
Marcelo Tosatti 已提交
4312

4313 4314 4315 4316 4317
    if (!qtest_enabled() && machine_class->deprecation_reason) {
        error_report("Machine type '%s' is deprecated: %s",
                     machine_class->name, machine_class->deprecation_reason);
    }

4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329
    /*
     * 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();

4330
    if (qtest_chrdev) {
4331
        qtest_init(qtest_chrdev, qtest_log, &error_fatal);
4332 4333
    }

4334 4335 4336 4337
    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");
4338
    bios_name = qemu_opt_get(machine_opts, "firmware");
4339

4340 4341
    opts = qemu_opts_find(qemu_find_opts("boot-opts"), NULL);
    if (opts) {
4342 4343
        boot_order = qemu_opt_get(opts, "order");
        if (boot_order) {
4344
            validate_bootdevices(boot_order, &error_fatal);
4345 4346
        }

4347 4348
        boot_once = qemu_opt_get(opts, "once");
        if (boot_once) {
4349
            validate_bootdevices(boot_once, &error_fatal);
4350 4351 4352
        }

        boot_menu = qemu_opt_get_bool(opts, "menu", boot_menu);
4353
        boot_strict = qemu_opt_get_bool(opts, "strict", false);
4354 4355
    }

4356 4357 4358 4359
    if (!boot_order) {
        boot_order = machine_class->default_boot_order;
    }

4360 4361
    if (!kernel_cmdline) {
        kernel_cmdline = "";
4362
        current_machine->kernel_cmdline = (char *)kernel_cmdline;
4363 4364
    }

4365
    linux_boot = (kernel_filename != NULL);
4366

4367
    if (!linux_boot && *kernel_cmdline != '\0') {
4368
        error_report("-append only allowed with -kernel option");
4369 4370 4371 4372
        exit(1);
    }

    if (!linux_boot && initrd_filename != NULL) {
4373
        error_report("-initrd only allowed with -kernel option");
4374 4375 4376
        exit(1);
    }

4377 4378 4379 4380 4381
    if (semihosting_enabled() && !semihosting_get_argc() && kernel_filename) {
        /* fall back to the -kernel/-append */
        semihosting_arg_fallback(kernel_filename, kernel_cmdline);
    }

4382
    os_set_line_buffering();
4383

4384 4385 4386
    /* spice needs the timers to be initialized by this point */
    qemu_spice_init();

4387
    cpu_ticks_init();
4388
    if (icount_opts) {
4389 4390
        if (!tcg_enabled()) {
            error_report("-icount is not allowed with hardware virtualization");
4391 4392 4393 4394
            exit(1);
        }
        configure_icount(icount_opts, &error_abort);
        qemu_opts_del(icount_opts);
4395
    }
4396

4397 4398 4399
    if (tcg_enabled()) {
        qemu_tcg_configure(accel_opts, &error_fatal);
    }
4400

4401 4402 4403 4404 4405 4406 4407 4408
    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
    }

4409 4410
    if (net_init_clients(&err) < 0) {
        error_report_err(err);
4411
        exit(1);
B
bellard 已提交
4412
    }
B
bellard 已提交
4413

4414 4415 4416
    qemu_opts_foreach(qemu_find_opts("object"),
                      user_creatable_add_opts_foreach,
                      object_create_delayed, &error_fatal);
4417

4418
    tpm_init();
4419

4420
    /* init the bluetooth world */
4421 4422
    if (foreach_device_config(DEV_BT, bt_parse))
        exit(1);
4423

4424 4425 4426
    if (!xen_enabled()) {
        /* On 32-bit hosts, QEMU is limited by virtual address space */
        if (ram_size > (2047 << 20) && HOST_LONG_BITS == 32) {
4427
            error_report("at most 2047 MB RAM can be simulated");
4428 4429 4430
            exit(1);
        }
    }
4431

L
lirans@il.ibm.com 已提交
4432
    blk_mig_init();
4433
    ram_mig_init();
4434
    dirty_bitmap_mig_init();
L
lirans@il.ibm.com 已提交
4435

4436 4437 4438 4439 4440 4441 4442
    /* 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);
    }

4443
    /* open the virtual block devices */
4444 4445 4446 4447 4448 4449 4450 4451 4452 4453
    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);
    }
4454 4455 4456 4457
    if (snapshot || replay_mode != REPLAY_MODE_NONE) {
        qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot,
                          NULL, NULL);
    }
4458
    if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func,
4459 4460
                          &machine_class->block_default_type, &error_fatal)) {
        /* We printed help */
4461
        exit(0);
4462
    }
4463

4464
    default_drive(default_cdrom, snapshot, machine_class->block_default_type, 2,
4465 4466 4467
                  CDROM_OPTS);
    default_drive(default_floppy, snapshot, IF_FLOPPY, 0, FD_OPTS);
    default_drive(default_sdcard, snapshot, IF_SD, 0, SD_OPTS);
4468

4469 4470
    qemu_opts_foreach(qemu_find_opts("mon"),
                      mon_init_func, NULL, &error_fatal);
4471

4472 4473
    if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
        exit(1);
4474 4475
    if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
        exit(1);
4476 4477
    if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
        exit(1);
4478 4479
    if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
        exit(1);
4480

4481
    /* If no default VGA is requested, the default is "none".  */
4482
    if (default_vga) {
4483 4484
        if (machine_class->default_display) {
            vga_model = machine_class->default_display;
4485
        } else if (vga_interface_available(VGA_CIRRUS)) {
4486
            vga_model = "cirrus";
4487
        } else if (vga_interface_available(VGA_STD)) {
4488 4489
            vga_model = "std";
        }
B
Blue Swirl 已提交
4490
    }
4491 4492 4493
    if (vga_model) {
        select_vgahw(vga_model);
    }
B
Blue Swirl 已提交
4494

4495 4496 4497 4498 4499 4500
    if (watchdog) {
        i = select_watchdog(watchdog);
        if (i > 0)
            exit (i == 1 ? 1 : 0);
    }

P
Pavel Dovgalyuk 已提交
4501 4502 4503 4504
    /* 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);
4505 4506
    qdev_machine_init();

4507
    current_machine->ram_size = ram_size;
4508 4509
    current_machine->maxram_size = maxram_size;
    current_machine->ram_slots = ram_slots;
4510 4511
    current_machine->boot_order = boot_order;

4512
    /* parse features once if machine provides default cpu_type */
4513 4514 4515
    current_machine->cpu_type = machine_class->default_cpu_type;
    if (cpu_model) {
        current_machine->cpu_type = parse_cpu_model(cpu_model);
4516
    }
4517
    parse_numa_opts(current_machine);
4518

4519 4520 4521 4522
    /* do monitor/qmp handling at preconfig state if requested */
    main_loop();

    /* from here on runstate is RUN_STATE_PRELAUNCH */
4523
    machine_run_board_init(current_machine);
4524

4525 4526
    realtime_init();

4527
    soundhw_init();
4528

4529 4530 4531 4532
    if (hax_enabled()) {
        hax_sync_vcpus();
    }

4533 4534
    qemu_opts_foreach(qemu_find_opts("fw_cfg"),
                      parse_fw_cfg, fw_cfg_find(), &error_fatal);
4535

4536
    /* init USB devices */
4537
    if (machine_usb(current_machine)) {
4538 4539
        if (foreach_device_config(DEV_USB, usb_parse) < 0)
            exit(1);
4540 4541
    }

4542 4543 4544
    /* Check if IGD GFX passthrough. */
    igd_gfx_passthru();

4545
    /* init generic devices */
4546
    rom_set_order_override(FW_CFG_ORDER_OVERRIDE_DEVICE);
4547 4548
    qemu_opts_foreach(qemu_find_opts("device"),
                      device_init_func, NULL, &error_fatal);
4549

4550 4551
    cpu_synchronize_all_post_init();

4552
    rom_reset_order_override();
4553

4554 4555 4556
    /* Did we create any drives that we failed to create a device for? */
    drive_check_orphaned();

4557 4558 4559 4560 4561 4562 4563 4564
    /* 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.
     */
4565
    if (!default_net && (!qtest_enabled() || has_defaults)) {
4566 4567 4568
        net_check_clients();
    }

4569
    if (boot_once) {
4570
        qemu_boot_set(boot_once, &error_fatal);
4571 4572 4573
        qemu_register_reset(restore_boot_order, g_strdup(boot_order));
    }

4574
    /* init local displays */
4575 4576
    ds = init_displaystate();
    qemu_display_init(ds, &dpy);
4577

4578 4579 4580
    /* must be after terminal init, SDL library changes signal handlers */
    os_setup_signal_handling();

4581
    /* init remote displays */
4582
#ifdef CONFIG_VNC
4583
    qemu_opts_foreach(qemu_find_opts("vnc"),
4584
                      vnc_init_func, NULL, &error_fatal);
4585
#endif
4586

4587 4588
    if (using_spice) {
        qemu_spice_display_init();
G
Gerd Hoffmann 已提交
4589
    }
4590

4591
    if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) {
4592
        exit(1);
4593 4594
    }

4595 4596
    qdev_machine_creation_done();

4597 4598 4599
    /* 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());
4600 4601
    qemu_run_machine_init_done_notifiers();

4602
    if (rom_check_and_register_reset() != 0) {
4603
        error_report("rom check and register reset failed");
4604 4605
        exit(1);
    }
4606

4607 4608
    replay_start();

P
Pavel Dovgalyuk 已提交
4609 4610 4611 4612
    /* 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);
4613
    qemu_system_reset(SHUTDOWN_CAUSE_NONE);
4614
    register_global_state();
4615
    if (loadvm) {
4616
        Error *local_err = NULL;
4617
        if (load_snapshot(loadvm, &local_err) < 0) {
4618
            error_report_err(local_err);
4619
            autostart = 0;
4620
            exit(1);
4621 4622
        }
    }
4623 4624 4625
    if (replay_mode != REPLAY_MODE_NONE) {
        replay_vmstate_init();
    }
4626

4627
    qdev_prop_check_globals();
4628 4629 4630 4631 4632
    if (vmstate_dump_file) {
        /* dump and exit */
        dump_vmstate_json_to_file(vmstate_dump_file);
        return 0;
    }
4633

G
Glauber Costa 已提交
4634
    if (incoming) {
4635 4636 4637
        Error *local_err = NULL;
        qemu_start_incoming_migration(incoming, &local_err);
        if (local_err) {
4638
            error_reportf_err(local_err, "-incoming %s: ", incoming);
4639
            exit(1);
4640
        }
4641
    } else if (autostart) {
4642
        vm_start();
4643
    }
4644

4645
    accel_setup_post(current_machine);
4646
    os_setup_post();
4647

4648
    main_loop();
4649

4650 4651
    gdbserver_cleanup();

4652 4653 4654
    /* No more vcpu or device emulation activity beyond this point */
    vm_shutdown();

4655
    job_cancel_sync_all();
4656
    bdrv_close_all();
4657

4658
    res_free();
4659

4660
    /* vhost-user must be cleaned up before chardevs.  */
4661
    tpm_cleanup();
4662
    net_cleanup();
4663
    audio_cleanup();
4664
    monitor_cleanup();
4665
    qemu_chr_cleanup();
4666
    user_creatable_cleanup();
4667
    migration_object_finalize();
4668
    /* TODO: unref root container, check all devices are ok */
4669

4670 4671
    return 0;
}
反馈
建议
客服 返回
顶部