vl.c 139.7 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 "qapi/error.h"
27
#include "qemu-version.h"
28 29
#include "qemu/cutils.h"
#include "qemu/help_option.h"
F
Fam Zheng 已提交
30
#include "qemu/uuid.h"
B
blueswir1 已提交
31

32
#ifdef CONFIG_SECCOMP
33
#include <sys/prctl.h>
34
#include "sysemu/seccomp.h"
35 36
#endif

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

50 51 52 53 54
#ifdef CONFIG_COCOA
#undef main
#define main qemu_main
#endif /* CONFIG_COCOA */

55

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

109
#include "disas/disas.h"
B
bellard 已提交
110

111

J
Jan Kiszka 已提交
112
#include "slirp/libslirp.h"
113

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

G
Gerd Hoffmann 已提交
119
#include "ui/qemu-spice.h"
120
#include "qapi/string-input-visitor.h"
P
Paolo Bonzini 已提交
121
#include "qapi/opts-visitor.h"
122
#include "qom/object_interfaces.h"
123
#include "exec/semihost.h"
124
#include "crypto/init.h"
125
#include "sysemu/replay.h"
126 127
#include "qapi/qapi-events-run-state.h"
#include "qapi/qapi-visit-block-core.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/qmp/qerror.h"
132
#include "sysemu/iothread.h"
G
Gerd Hoffmann 已提交
133

134
#define MAX_VIRTIO_CONSOLES 1
135
#define MAX_SCLP_CONSOLES 1
136

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
int nb_nics;
B
bellard 已提交
148
NICInfo nd_table[MAX_NICS];
P
Paolo Bonzini 已提交
149
int autostart;
150 151
static int rtc_utc = 1;
static int rtc_date_offset = -1; /* -1 means no change */
152
QEMUClockType rtc_clock;
153
int vga_interface_type = VGA_NONE;
154
static DisplayOptions dpy;
155
int no_frame;
156 157 158 159
Chardev *serial_hds[MAX_SERIAL_PORTS];
Chardev *parallel_hds[MAX_PARALLEL_PORTS];
Chardev *virtcon_hds[MAX_VIRTIO_CONSOLES];
Chardev *sclp_hds[MAX_SCLP_CONSOLES];
160
int win2k_install_hack = 0;
161
int singlestep = 0;
162 163
int smp_cpus;
unsigned int max_cpus;
164 165
int smp_cores = 1;
int smp_threads = 1;
B
bellard 已提交
166
int acpi_enabled = 1;
167
int no_hpet = 0;
168
int fd_bootchk = 1;
B
Blue Swirl 已提交
169
static int no_reboot;
A
aurel32 已提交
170
int no_shutdown = 0;
171
int cursor_hide = 1;
172
int graphic_rotate = 0;
173
const char *watchdog;
174
QEMUOptionRom option_rom[MAX_OPTION_ROMS];
175
int nb_option_roms;
176
int old_param = 0;
177
const char *qemu_name;
178
int alt_grab = 0;
179
int ctrl_grab = 0;
180 181
unsigned int nb_prom_envs = 0;
const char *prom_envs[MAX_PROM_ENVS];
182
int boot_menu;
183
bool boot_strict;
184
uint8_t *boot_splash_filedata;
185
size_t boot_splash_filedata_size;
186
uint8_t qemu_extra_params_fw[2];
187

188
int icount_align_option;
189

190
/* The bytes in qemu_uuid are in the order specified by RFC4122, _not_ in the
191 192
 * little-endian "wire format" described in the SMBIOS 2.6 specification.
 */
193
QemuUUID qemu_uuid;
194
bool qemu_uuid_set;
195

G
Gerd Hoffmann 已提交
196 197 198
static NotifierList exit_notifiers =
    NOTIFIER_LIST_INITIALIZER(exit_notifiers);

199 200 201
static NotifierList machine_init_done_notifiers =
    NOTIFIER_LIST_INITIALIZER(machine_init_done_notifiers);

202
bool xen_allowed;
203 204
uint32_t xen_domid;
enum xen_mode xen_mode = XEN_EMULATE;
205
bool xen_domid_restrict;
206

207
static int has_defaults = 1;
208
static int default_serial = 1;
209
static int default_parallel = 1;
210
static int default_virtcon = 1;
211
static int default_sclp = 1;
212
static int default_monitor = 1;
213 214 215
static int default_floppy = 1;
static int default_cdrom = 1;
static int default_sdcard = 1;
216
static int default_vga = 1;
217
static int default_net = 1;
218 219 220 221 222

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

243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
static QemuOptsList qemu_rtc_opts = {
    .name = "rtc",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_rtc_opts.head),
    .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_sandbox_opts = {
    .name = "sandbox",
    .implied_opt_name = "enable",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_sandbox_opts.head),
    .desc = {
        {
            .name = "enable",
            .type = QEMU_OPT_BOOL,
        },
270 271 272 273
        {
            .name = "obsolete",
            .type = QEMU_OPT_STRING,
        },
274 275 276 277
        {
            .name = "elevateprivileges",
            .type = QEMU_OPT_STRING,
        },
278 279 280 281
        {
            .name = "spawn",
            .type = QEMU_OPT_STRING,
        },
282 283 284 285
        {
            .name = "resourcecontrol",
            .type = QEMU_OPT_STRING,
        },
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
        { /* 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 = {
312 313 314 315 316 317
        /*
         * no elements => accept any
         * sanity checking will happen later
         * when setting machine properties
         */
        { }
318 319 320
    },
};

321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
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 */ }
    },
};

341 342
static QemuOptsList qemu_boot_opts = {
    .name = "boot-opts",
343 344
    .implied_opt_name = "order",
    .merge_lists = true,
345 346 347 348 349 350 351 352 353 354
    .head = QTAILQ_HEAD_INITIALIZER(qemu_boot_opts.head),
    .desc = {
        {
            .name = "order",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "once",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "menu",
355
            .type = QEMU_OPT_BOOL,
356 357 358 359 360 361 362 363 364
        }, {
            .name = "splash",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "splash-time",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "reboot-timeout",
            .type = QEMU_OPT_STRING,
365 366
        }, {
            .name = "strict",
367
            .type = QEMU_OPT_BOOL,
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
        },
        { /*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 = {
        { }
    },
};

403 404 405 406 407
static QemuOptsList qemu_tpmdev_opts = {
    .name = "tpmdev",
    .implied_opt_name = "type",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_tpmdev_opts.head),
    .desc = {
408
        /* options are defined in the TPM backends */
409 410 411 412
        { /* end of list */ }
    },
};

413 414 415 416 417 418 419 420 421 422 423 424
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 */ }
    },
};

425 426 427 428 429 430 431 432 433 434 435 436
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 */ }
    },
};

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

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

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

515 516 517 518 519 520 521 522 523 524 525
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,
526 527 528
        }, {
            .name = "arg",
            .type = QEMU_OPT_STRING,
529 530 531 532 533
        },
        { /* end of list */ }
    },
};

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

557 558 559 560 561 562 563
/**
 * Get machine options
 *
 * Returns: machine options (never null).
 */
QemuOpts *qemu_get_machine_opts(void)
{
564
    return qemu_find_opts_singleton("machine");
565 566
}

567 568 569 570 571
const char *qemu_get_vm_name(void)
{
    return qemu_name;
}

572 573
static void res_free(void)
{
574 575
    g_free(boot_splash_filedata);
    boot_splash_filedata = NULL;
576 577
}

578
static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp)
579 580 581 582 583 584 585 586 587 588 589 590 591 592
{
    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;
}

593 594 595
/***********************************************************/
/* QEMU state */

596
static RunState current_run_state = RUN_STATE_PRELAUNCH;
597

598 599
/* We use RUN_STATE__MAX but any invalid value will do */
static RunState vmstop_requested = RUN_STATE__MAX;
600 601
static QemuMutex vmstop_lock;

602 603 604 605 606 607 608
typedef struct {
    RunState from;
    RunState to;
} RunStateTransition;

static const RunStateTransition runstate_transitions_def[] = {
    /*     from      ->     to      */
609
    { RUN_STATE_DEBUG, RUN_STATE_RUNNING },
610
    { RUN_STATE_DEBUG, RUN_STATE_FINISH_MIGRATE },
611
    { RUN_STATE_DEBUG, RUN_STATE_PRELAUNCH },
612

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

626
    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED },
627
    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE },
628
    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PRELAUNCH },
629

630
    { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING },
631
    { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE },
632
    { RUN_STATE_IO_ERROR, RUN_STATE_PRELAUNCH },
633

634
    { RUN_STATE_PAUSED, RUN_STATE_RUNNING },
635
    { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE },
636
    { RUN_STATE_PAUSED, RUN_STATE_POSTMIGRATE },
637
    { RUN_STATE_PAUSED, RUN_STATE_PRELAUNCH },
638
    { RUN_STATE_PAUSED, RUN_STATE_COLO},
639

640
    { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING },
641
    { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE },
642
    { RUN_STATE_POSTMIGRATE, RUN_STATE_PRELAUNCH },
643

644
    { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING },
645
    { RUN_STATE_PRELAUNCH, RUN_STATE_FINISH_MIGRATE },
646
    { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE },
647

648
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING },
649
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PAUSED },
650
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE },
651
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PRELAUNCH },
652
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_COLO},
653

654
    { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING },
655
    { RUN_STATE_RESTORE_VM, RUN_STATE_PRELAUNCH },
656

657 658
    { RUN_STATE_COLO, RUN_STATE_RUNNING },

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

671
    { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING },
672

673
    { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
674
    { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE },
675
    { RUN_STATE_SHUTDOWN, RUN_STATE_PRELAUNCH },
676

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

684
    { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
685
    { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },
686
    { RUN_STATE_WATCHDOG, RUN_STATE_PRELAUNCH },
687
    { RUN_STATE_WATCHDOG, RUN_STATE_COLO},
688

689
    { RUN_STATE_GUEST_PANICKED, RUN_STATE_RUNNING },
690
    { RUN_STATE_GUEST_PANICKED, RUN_STATE_FINISH_MIGRATE },
691
    { RUN_STATE_GUEST_PANICKED, RUN_STATE_PRELAUNCH },
692

693
    { RUN_STATE__MAX, RUN_STATE__MAX },
694 695
};

696
static bool runstate_valid_transitions[RUN_STATE__MAX][RUN_STATE__MAX];
697

698 699 700 701 702
bool runstate_check(RunState state)
{
    return current_run_state == state;
}

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

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

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

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

    qemu_mutex_init(&vmstop_lock);
725 726 727
}

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

732 733 734 735
    if (current_run_state == new_state) {
        return;
    }

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

746
int runstate_is_running(void)
747
{
748
    return runstate_check(RUN_STATE_RUNNING);
749 750
}

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

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

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

    return info;
766 767
}

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

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

789 790
/***********************************************************/
/* real time host monotonic timer */
791

792 793 794 795 796
static time_t qemu_time(void)
{
    return qemu_clock_get_ms(QEMU_CLOCK_HOST) / 1000;
}

797 798 799 800
/***********************************************************/
/* host time/date access */
void qemu_get_timedate(struct tm *tm, int offset)
{
801
    time_t ti = qemu_time();
802 803 804 805

    ti += offset;
    if (rtc_date_offset == -1) {
        if (rtc_utc)
806
            gmtime_r(&ti, tm);
807
        else
808
            localtime_r(&ti, tm);
809 810
    } else {
        ti -= rtc_date_offset;
811
        gmtime_r(&ti, tm);
812 813 814 815 816 817 818 819 820 821
    }
}

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

    if (rtc_date_offset == -1)
        if (rtc_utc)
            seconds = mktimegm(tm);
822 823 824 825 826
        else {
            struct tm tmp = *tm;
            tmp.tm_isdst = -1; /* use timezone to figure it out */
            seconds = mktime(&tmp);
	}
827 828 829
    else
        seconds = mktimegm(tm) + rtc_date_offset;

830
    return seconds - qemu_time();
831 832
}

833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
static void configure_rtc_date_offset(const char *startdate, int legacy)
{
    time_t rtc_start_date;
    struct tm tm;

    if (!strcmp(startdate, "now") && legacy) {
        rtc_date_offset = -1;
    } else {
        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;
        } else {
            goto date_fail;
        }
        tm.tm_year -= 1900;
        tm.tm_mon--;
        rtc_start_date = mktimegm(&tm);
        if (rtc_start_date == -1) {
        date_fail:
864 865 866
            error_report("invalid date format");
            error_printf("valid formats: "
                         "'2006-06-17T16:01:21' or '2006-06-17'\n");
867 868
            exit(1);
        }
869
        rtc_date_offset = qemu_time() - rtc_start_date;
870 871 872 873 874 875 876 877 878 879 880 881
    }
}

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

    value = qemu_opt_get(opts, "base");
    if (value) {
        if (!strcmp(value, "utc")) {
            rtc_utc = 1;
        } else if (!strcmp(value, "localtime")) {
882
            Error *blocker = NULL;
883
            rtc_utc = 0;
884 885 886
            error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED,
                      "-rtc base=localtime");
            replay_add_blocker(blocker);
887 888 889 890
        } else {
            configure_rtc_date_offset(value, 0);
        }
    }
J
Jan Kiszka 已提交
891 892 893
    value = qemu_opt_get(opts, "clock");
    if (value) {
        if (!strcmp(value, "host")) {
894
            rtc_clock = QEMU_CLOCK_HOST;
P
Paolo Bonzini 已提交
895
        } else if (!strcmp(value, "rt")) {
896
            rtc_clock = QEMU_CLOCK_REALTIME;
J
Jan Kiszka 已提交
897
        } else if (!strcmp(value, "vm")) {
898
            rtc_clock = QEMU_CLOCK_VIRTUAL;
J
Jan Kiszka 已提交
899
        } else {
900
            error_report("invalid option value '%s'", value);
J
Jan Kiszka 已提交
901 902 903
            exit(1);
        }
    }
904 905
    value = qemu_opt_get(opts, "driftfix");
    if (value) {
B
Blue Swirl 已提交
906
        if (!strcmp(value, "slew")) {
907 908 909 910
            static GlobalProperty slew_lost_ticks = {
                .driver   = "mc146818rtc",
                .property = "lost_tick_policy",
                .value    = "slew",
911 912
            };

913
            qdev_prop_register_global(&slew_lost_ticks);
B
Blue Swirl 已提交
914
        } else if (!strcmp(value, "none")) {
915
            /* discard is default */
916
        } else {
917
            error_report("invalid option value '%s'", value);
918 919 920 921 922
            exit(1);
        }
    }
}

923 924 925 926 927
/***********************************************************/
/* Bluetooth support */
static int nb_hcis;
static int cur_hci;
static struct HCIInfo *hci_table[MAX_NICS];
928

929 930 931 932 933 934 935 936
struct HCIInfo *qemu_next_hci(void)
{
    if (cur_hci == nb_hcis)
        return &null_hci;

    return hci_table[cur_hci++];
}

937 938 939
static int bt_hci_parse(const char *str)
{
    struct HCIInfo *hci;
940
    bdaddr_t bdaddr;
941 942

    if (nb_hcis >= MAX_NICS) {
943
        error_report("too many bluetooth HCIs (max %i)", MAX_NICS);
944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968
        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)
969 970
        warn_report("adding a VHCI to an empty scatternet %i",
                    vlan_id);
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987

    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) {
988
            error_report("unrecognised bluetooth vlan Id");
989 990 991 992 993 994 995
            return 0;
        }
    }

    vlan = qemu_find_bt_vlan(vlan_id);

    if (!vlan->slave)
996 997
        warn_report("adding a slave device to an empty scatternet %i",
                    vlan_id);
998 999 1000 1001

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

1002
    error_report("unsupported bluetooth device '%s'", devname);
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
    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) {
1025
                        error_report("bad scatternet '%s'", p);
1026 1027 1028
                        return 1;
                    }
                } else {
1029
                    error_report("bad parameter '%s'", endp + 1);
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
                    return 1;
                }
            } else
                vlan = 0;

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

1041
    error_report("bad bluetooth parameter '%s'", opt);
1042 1043 1044
    return 1;
}

1045
static int parse_sandbox(void *opaque, QemuOpts *opts, Error **errp)
1046 1047 1048
{
    if (qemu_opt_get_bool(opts, "enable", false)) {
#ifdef CONFIG_SECCOMP
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
        uint32_t seccomp_opts = QEMU_SECCOMP_SET_DEFAULT
                | QEMU_SECCOMP_SET_OBSOLETE;
        const char *value = NULL;

        value = qemu_opt_get(opts, "obsolete");
        if (value) {
            if (g_str_equal(value, "allow")) {
                seccomp_opts &= ~QEMU_SECCOMP_SET_OBSOLETE;
            } else if (g_str_equal(value, "deny")) {
                /* this is the default option, this if is here
                 * to provide a little bit of consistency for
                 * the command line */
            } else {
                error_report("invalid argument for obsolete");
                return -1;
            }
        }

1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088
        value = qemu_opt_get(opts, "elevateprivileges");
        if (value) {
            if (g_str_equal(value, "deny")) {
                seccomp_opts |= QEMU_SECCOMP_SET_PRIVILEGED;
            } else if (g_str_equal(value, "children")) {
                seccomp_opts |= QEMU_SECCOMP_SET_PRIVILEGED;

                /* calling prctl directly because we're
                 * not sure if host has CAP_SYS_ADMIN set*/
                if (prctl(PR_SET_NO_NEW_PRIVS, 1)) {
                    error_report("failed to set no_new_privs "
                                 "aborting");
                    return -1;
                }
            } else if (g_str_equal(value, "allow")) {
                /* default value */
            } else {
                error_report("invalid argument for elevateprivileges");
                return -1;
            }
        }

1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
        value = qemu_opt_get(opts, "spawn");
        if (value) {
            if (g_str_equal(value, "deny")) {
                seccomp_opts |= QEMU_SECCOMP_SET_SPAWN;
            } else if (g_str_equal(value, "allow")) {
                /* default value */
            } else {
                error_report("invalid argument for spawn");
                return -1;
            }
        }

1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
        value = qemu_opt_get(opts, "resourcecontrol");
        if (value) {
            if (g_str_equal(value, "deny")) {
                seccomp_opts |= QEMU_SECCOMP_SET_RESOURCECTL;
            } else if (g_str_equal(value, "allow")) {
                /* default value */
            } else {
                error_report("invalid argument for resourcecontrol");
                return -1;
            }
        }

1113
        if (seccomp_start(seccomp_opts) < 0) {
1114 1115
            error_report("failed to install seccomp syscall filter "
                         "in the kernel");
1116 1117 1118
            return -1;
        }
#else
1119
        error_report("seccomp support is disabled");
1120 1121 1122 1123 1124 1125 1126
        return -1;
#endif
    }

    return 0;
}

1127
static int parse_name(void *opaque, QemuOpts *opts, Error **errp)
1128 1129 1130
{
    const char *proc_name;

1131 1132 1133
    if (qemu_opt_get(opts, "debug-threads")) {
        qemu_thread_naming(qemu_opt_get_bool(opts, "debug-threads", false));
    }
1134 1135 1136 1137 1138 1139
    qemu_name = qemu_opt_get(opts, "guest");

    proc_name = qemu_opt_get(opts, "process");
    if (proc_name) {
        os_set_proc_name(proc_name);
    }
1140 1141

    return 0;
1142 1143
}

1144 1145 1146 1147 1148
bool defaults_enabled(void)
{
    return has_defaults;
}

1149
#ifndef _WIN32
1150
static int parse_add_fd(void *opaque, QemuOpts *opts, Error **errp)
1151 1152 1153 1154
{
    int fd, dupfd, flags;
    int64_t fdset_id;
    const char *fd_opaque = NULL;
1155
    AddfdInfo *fdinfo;
1156 1157 1158 1159 1160 1161

    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) {
1162
        error_report("fd option is required and must be non-negative");
1163 1164 1165 1166
        return -1;
    }

    if (fd <= STDERR_FILENO) {
1167
        error_report("fd cannot be a standard I/O stream");
1168 1169 1170 1171 1172 1173 1174 1175 1176
        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)) {
1177
        error_report("fd is not valid or already in use");
1178 1179 1180 1181
        return -1;
    }

    if (fdset_id < 0) {
1182
        error_report("set option is required and must be non-negative");
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
        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) {
1195
        error_report("error duplicating fd: %s", strerror(errno));
1196 1197 1198 1199
        return -1;
    }

    /* add the duplicate fd, and optionally the opaque string, to the fd set */
1200 1201 1202
    fdinfo = monitor_fdset_add_fd(dupfd, true, fdset_id, !!fd_opaque, fd_opaque,
                                  &error_abort);
    g_free(fdinfo);
1203 1204 1205 1206

    return 0;
}

1207
static int cleanup_add_fd(void *opaque, QemuOpts *opts, Error **errp)
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
{
    int fd;

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

    return 0;
}
#endif

1218 1219 1220
/***********************************************************/
/* QEMU Block devices */

1221 1222 1223 1224 1225 1226
#define HD_OPTS "media=disk"
#define CDROM_OPTS "media=cdrom"
#define FD_OPTS ""
#define PFLASH_OPTS ""
#define MTD_OPTS ""
#define SD_OPTS ""
1227

1228
static int drive_init_func(void *opaque, QemuOpts *opts, Error **errp)
1229
{
1230
    BlockInterfaceType *block_default_type = opaque;
1231

1232
    return drive_new(opts, *block_default_type) == NULL;
1233 1234
}

1235
static int drive_enable_snapshot(void *opaque, QemuOpts *opts, Error **errp)
1236
{
G
Gonglei 已提交
1237
    if (qemu_opt_get(opts, "snapshot") == NULL) {
1238
        qemu_opt_set(opts, "snapshot", "on", &error_abort);
1239 1240 1241 1242
    }
    return 0;
}

1243 1244
static void default_drive(int enable, int snapshot, BlockInterfaceType type,
                          int index, const char *optstr)
1245 1246
{
    QemuOpts *opts;
1247
    DriveInfo *dinfo;
1248 1249 1250 1251 1252 1253 1254

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

    opts = drive_add(type, index, NULL, optstr);
    if (snapshot) {
1255
        drive_enable_snapshot(NULL, opts, NULL);
1256
    }
1257 1258 1259

    dinfo = drive_new(opts, type);
    if (!dinfo) {
1260 1261
        exit(1);
    }
1262 1263
    dinfo->is_default = true;

1264 1265
}

1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292
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)
1293
{
1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
    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) {
            sockets = sockets > 0 ? sockets : 1;
            cores = cores > 0 ? cores : 1;
1304
            threads = threads > 0 ? threads : 1;
1305 1306 1307
            if (cpus == 0) {
                cpus = cores * threads * sockets;
            }
1308 1309 1310
        } else if (cores == 0) {
            threads = threads > 0 ? threads : 1;
            cores = cpus / (sockets * threads);
1311
            cores = cores > 0 ? cores : 1;
1312
        } else if (threads == 0) {
1313
            threads = cpus / (cores * sockets);
1314
            threads = threads > 0 ? threads : 1;
1315
        } else if (sockets * cores * threads < cpus) {
1316 1317 1318 1319
            error_report("cpu topology: "
                         "sockets (%u) * cores (%u) * threads (%u) < "
                         "smp_cpus (%u)",
                         sockets, cores, threads, cpus);
1320
            exit(1);
1321
        }
1322

1323
        max_cpus = qemu_opt_get_number(opts, "maxcpus", cpus);
A
Andrew Jones 已提交
1324 1325 1326 1327 1328 1329

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

1330
        if (sockets * cores * threads > max_cpus) {
1331 1332 1333 1334
            error_report("cpu topology: "
                         "sockets (%u) * cores (%u) * threads (%u) > "
                         "maxcpus (%u)",
                         sockets, cores, threads, max_cpus);
1335 1336
            exit(1);
        }
1337 1338

        smp_cpus = cpus;
A
Andrew Jones 已提交
1339 1340
        smp_cores = cores;
        smp_threads = threads;
1341 1342
    }

A
Andrew Jones 已提交
1343
    if (smp_cpus > 1) {
1344 1345 1346 1347
        Error *blocker = NULL;
        error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED, "smp");
        replay_add_blocker(blocker);
    }
1348 1349
}

1350
static void realtime_init(void)
1351 1352 1353
{
    if (enable_mlock) {
        if (os_mlock() < 0) {
1354
            error_report("locking memory failed");
1355 1356 1357 1358 1359
            exit(1);
        }
    }
}

1360 1361 1362 1363 1364 1365

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

1366 1367 1368 1369 1370 1371
/***********************************************************/
/* Semihosting */

typedef struct SemihostingConfig {
    bool enabled;
    SemihostingTarget target;
1372 1373 1374
    const char **argv;
    int argc;
    const char *cmdline; /* concatenated argv */
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
} SemihostingConfig;

static SemihostingConfig semihosting;

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

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

1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
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, " ");
    }
}

1441 1442 1443 1444 1445 1446 1447
/* 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 已提交
1448 1449 1450
/***********************************************************/
/* USB devices */

1451
static int usb_device_add(const char *devname)
B
bellard 已提交
1452
{
1453
    USBDevice *dev = NULL;
B
bellard 已提交
1454

1455
    if (!machine_usb(current_machine)) {
B
bellard 已提交
1456
        return -1;
1457
    }
B
bellard 已提交
1458

1459
    dev = usbdevice_create(devname);
P
pbrook 已提交
1460 1461 1462
    if (!dev)
        return -1;

B
bellard 已提交
1463 1464 1465
    return 0;
}

1466 1467
static int usb_parse(const char *cmdline)
{
1468
    int r;
1469
    r = usb_device_add(cmdline);
1470
    if (r < 0) {
1471
        error_report("could not add USB device '%s'", cmdline);
1472 1473
    }
    return r;
1474 1475
}

1476 1477 1478
/***********************************************************/
/* machine registration */

1479
MachineState *current_machine;
1480

1481
static MachineClass *find_machine(const char *name)
1482
{
1483
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1484
    MachineClass *mc = NULL;
1485

1486
    for (el = machines; el; el = el->next) {
1487
        MachineClass *temp = el->data;
1488

1489
        if (!strcmp(temp->name, name)) {
1490
            mc = temp;
1491 1492
            break;
        }
1493 1494
        if (temp->alias &&
            !strcmp(temp->alias, name)) {
1495
            mc = temp;
1496 1497
            break;
        }
1498
    }
1499 1500

    g_slist_free(machines);
1501
    return mc;
1502 1503
}

1504
MachineClass *find_default_machine(void)
1505
{
1506
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1507
    MachineClass *mc = NULL;
1508

1509
    for (el = machines; el; el = el->next) {
1510
        MachineClass *temp = el->data;
1511

1512
        if (temp->is_default) {
1513
            mc = temp;
1514
            break;
1515 1516
        }
    }
1517 1518

    g_slist_free(machines);
1519
    return mc;
1520 1521
}

1522 1523
MachineInfoList *qmp_query_machines(Error **errp)
{
1524
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1525 1526
    MachineInfoList *mach_list = NULL;

1527 1528
    for (el = machines; el; el = el->next) {
        MachineClass *mc = el->data;
1529 1530 1531 1532
        MachineInfoList *entry;
        MachineInfo *info;

        info = g_malloc0(sizeof(*info));
1533
        if (mc->is_default) {
1534 1535 1536 1537
            info->has_is_default = true;
            info->is_default = true;
        }

1538
        if (mc->alias) {
1539
            info->has_alias = true;
1540
            info->alias = g_strdup(mc->alias);
1541 1542
        }

1543 1544
        info->name = g_strdup(mc->name);
        info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
1545
        info->hotpluggable_cpus = mc->has_hotpluggable_cpus;
1546 1547 1548 1549 1550 1551 1552

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

1553
    g_slist_free(machines);
1554 1555 1556
    return mach_list;
}

1557 1558 1559
static int machine_help_func(QemuOpts *opts, MachineState *machine)
{
    ObjectProperty *prop;
1560
    ObjectPropertyIterator iter;
1561 1562 1563 1564 1565

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

1566 1567
    object_property_iter_init(&iter, OBJECT(machine));
    while ((prop = object_property_iter_next(&iter))) {
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
        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;
}

1584 1585 1586
/***********************************************************/
/* main execution loop */

1587 1588 1589
struct vm_change_state_entry {
    VMChangeStateHandler *cb;
    void *opaque;
1590
    QLIST_ENTRY (vm_change_state_entry) entries;
1591 1592
};

1593
static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
1594 1595 1596 1597 1598 1599

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

1600
    e = g_malloc0(sizeof (*e));
1601 1602 1603

    e->cb = cb;
    e->opaque = opaque;
1604
    QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
1605 1606 1607 1608 1609
    return e;
}

void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
{
1610
    QLIST_REMOVE (e, entries);
1611
    g_free (e);
1612 1613
}

1614
void vm_state_notify(int running, RunState state)
1615
{
1616
    VMChangeStateEntry *e, *next;
1617

1618
    trace_vm_state_notify(running, state);
1619

1620
    QLIST_FOREACH_SAFE(e, &vm_change_state_head, entries, next) {
1621
        e->cb(e->opaque, running, state);
1622 1623 1624
    }
}

1625 1626 1627
static ShutdownCause reset_requested;
static ShutdownCause shutdown_requested;
static int shutdown_signal;
1628
static pid_t shutdown_pid;
B
bellard 已提交
1629
static int powerdown_requested;
1630
static int debug_requested;
1631
static int suspend_requested;
L
Liu, Jinsong 已提交
1632
static WakeupReason wakeup_reason;
1633 1634
static NotifierList powerdown_notifiers =
    NOTIFIER_LIST_INITIALIZER(powerdown_notifiers);
1635 1636 1637 1638
static NotifierList suspend_notifiers =
    NOTIFIER_LIST_INITIALIZER(suspend_notifiers);
static NotifierList wakeup_notifiers =
    NOTIFIER_LIST_INITIALIZER(wakeup_notifiers);
L
Liu, Jinsong 已提交
1639
static uint32_t wakeup_reason_mask = ~(1 << QEMU_WAKEUP_REASON_NONE);
1640

1641
ShutdownCause qemu_shutdown_requested_get(void)
1642 1643 1644 1645
{
    return shutdown_requested;
}

1646
ShutdownCause qemu_reset_requested_get(void)
1647 1648 1649 1650
{
    return reset_requested;
}

B
Blue Swirl 已提交
1651
static int qemu_shutdown_requested(void)
A
aurel32 已提交
1652
{
1653
    return atomic_xchg(&shutdown_requested, SHUTDOWN_CAUSE_NONE);
A
aurel32 已提交
1654 1655
}

B
Blue Swirl 已提交
1656
static void qemu_kill_report(void)
1657
{
1658
    if (!qtest_driver() && shutdown_signal) {
1659 1660 1661 1662
        if (shutdown_pid == 0) {
            /* This happens for eg ^C at the terminal, so it's worth
             * avoiding printing an odd message in that case.
             */
1663
            error_report("terminating on signal %d", shutdown_signal);
1664
        } else {
1665 1666 1667 1668 1669 1670
            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);
1671
        }
1672
        shutdown_signal = 0;
1673 1674 1675
    }
}

1676
static ShutdownCause qemu_reset_requested(void)
A
aurel32 已提交
1677
{
1678 1679
    ShutdownCause r = reset_requested;

P
Pavel Dovgalyuk 已提交
1680
    if (r && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) {
1681
        reset_requested = SHUTDOWN_CAUSE_NONE;
P
Pavel Dovgalyuk 已提交
1682 1683
        return r;
    }
1684
    return SHUTDOWN_CAUSE_NONE;
A
aurel32 已提交
1685 1686
}

1687 1688 1689
static int qemu_suspend_requested(void)
{
    int r = suspend_requested;
P
Pavel Dovgalyuk 已提交
1690 1691 1692 1693 1694
    if (r && replay_checkpoint(CHECKPOINT_SUSPEND_REQUESTED)) {
        suspend_requested = 0;
        return r;
    }
    return false;
1695 1696
}

L
Liu, Jinsong 已提交
1697
static WakeupReason qemu_wakeup_requested(void)
1698
{
L
Liu, Jinsong 已提交
1699
    return wakeup_reason;
1700 1701
}

B
Blue Swirl 已提交
1702
static int qemu_powerdown_requested(void)
A
aurel32 已提交
1703 1704 1705 1706 1707 1708
{
    int r = powerdown_requested;
    powerdown_requested = 0;
    return r;
}

1709 1710 1711 1712 1713 1714 1715
static int qemu_debug_requested(void)
{
    int r = debug_requested;
    debug_requested = 0;
    return r;
}

1716 1717 1718 1719
/*
 * Reset the VM. Issue an event unless @reason is SHUTDOWN_CAUSE_NONE.
 */
void qemu_system_reset(ShutdownCause reason)
1720
{
1721 1722 1723 1724
    MachineClass *mc;

    mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;

1725 1726
    cpu_synchronize_all_states();

1727 1728
    if (mc && mc->reset) {
        mc->reset();
1729 1730 1731
    } else {
        qemu_devices_reset();
    }
1732
    if (reason) {
1733 1734
        qapi_event_send_reset(shutdown_caused_by_guest(reason),
                              &error_abort);
J
Jan Kiszka 已提交
1735
    }
1736
    cpu_synchronize_all_post_reset();
1737 1738
}

1739
void qemu_system_guest_panicked(GuestPanicInformation *info)
1740
{
1741
    qemu_log_mask(LOG_GUEST_ERROR, "Guest crashed");
1742

1743 1744 1745
    if (current_cpu) {
        current_cpu->crash_occurred = true;
    }
1746 1747
    qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE,
                                   !!info, info, &error_abort);
1748
    vm_stop(RUN_STATE_GUEST_PANICKED);
1749 1750
    if (!no_shutdown) {
        qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF,
1751
                                       !!info, info, &error_abort);
1752
        qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC);
1753
    }
1754 1755

    if (info) {
1756
        if (info->type == GUEST_PANIC_INFORMATION_TYPE_HYPER_V) {
1757
            qemu_log_mask(LOG_GUEST_ERROR, "\nHV crash parameters: (%#"PRIx64
1758
                          " %#"PRIx64" %#"PRIx64" %#"PRIx64" %#"PRIx64")\n",
1759 1760 1761 1762 1763
                          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);
1764 1765 1766 1767 1768 1769 1770
        } 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);
1771
        }
1772 1773
        qapi_free_GuestPanicInformation(info);
    }
1774 1775
}

1776
void qemu_system_reset_request(ShutdownCause reason)
1777
{
B
bellard 已提交
1778
    if (no_reboot) {
1779
        shutdown_requested = reason;
B
bellard 已提交
1780
    } else {
1781
        reset_requested = reason;
B
bellard 已提交
1782
    }
1783
    cpu_stop_current();
1784
    qemu_notify_event();
1785 1786
}

1787 1788 1789 1790
static void qemu_system_suspend(void)
{
    pause_all_vcpus();
    notifier_list_notify(&suspend_notifiers, NULL);
1791
    runstate_set(RUN_STATE_SUSPENDED);
W
Wenchao Xia 已提交
1792
    qapi_event_send_suspend(&error_abort);
1793 1794 1795 1796
}

void qemu_system_suspend_request(void)
{
1797
    if (runstate_check(RUN_STATE_SUSPENDED)) {
1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811
        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)
{
1812 1813
    trace_system_wakeup_request(reason);

1814
    if (!runstate_check(RUN_STATE_SUSPENDED)) {
1815 1816 1817 1818 1819
        return;
    }
    if (!(wakeup_reason_mask & (1 << reason))) {
        return;
    }
1820
    runstate_set(RUN_STATE_RUNNING);
L
Liu, Jinsong 已提交
1821
    wakeup_reason = reason;
1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
    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);
}

1839 1840 1841 1842
void qemu_system_killed(int signal, pid_t pid)
{
    shutdown_signal = signal;
    shutdown_pid = pid;
1843
    no_shutdown = 0;
P
Pavel Dovgalyuk 已提交
1844 1845 1846 1847

    /* Cannot call qemu_system_shutdown_request directly because
     * we are in a signal handler.
     */
1848
    shutdown_requested = SHUTDOWN_CAUSE_HOST_SIGNAL;
P
Pavel Dovgalyuk 已提交
1849
    qemu_notify_event();
1850 1851
}

1852
void qemu_system_shutdown_request(ShutdownCause reason)
1853
{
1854 1855 1856
    trace_qemu_system_shutdown_request(reason);
    replay_shutdown_request(reason);
    shutdown_requested = reason;
1857
    qemu_notify_event();
1858 1859
}

1860 1861
static void qemu_system_powerdown(void)
{
1862
    qapi_event_send_powerdown(&error_abort);
1863 1864 1865
    notifier_list_notify(&powerdown_notifiers, NULL);
}

B
bellard 已提交
1866 1867
void qemu_system_powerdown_request(void)
{
1868
    trace_qemu_system_powerdown_request();
B
bellard 已提交
1869
    powerdown_requested = 1;
1870 1871 1872
    qemu_notify_event();
}

1873 1874 1875 1876 1877
void qemu_register_powerdown_notifier(Notifier *notifier)
{
    notifier_list_add(&powerdown_notifiers, notifier);
}

1878 1879 1880
void qemu_system_debug_request(void)
{
    debug_requested = 1;
1881
    qemu_notify_event();
1882 1883
}

1884 1885 1886
static bool main_loop_should_exit(void)
{
    RunState r;
1887 1888
    ShutdownCause request;

1889 1890 1891
    if (qemu_debug_requested()) {
        vm_stop(RUN_STATE_DEBUG);
    }
1892 1893 1894
    if (qemu_suspend_requested()) {
        qemu_system_suspend();
    }
1895 1896
    request = qemu_shutdown_requested();
    if (request) {
1897
        qemu_kill_report();
1898 1899
        qapi_event_send_shutdown(shutdown_caused_by_guest(request),
                                 &error_abort);
1900 1901 1902 1903 1904 1905
        if (no_shutdown) {
            vm_stop(RUN_STATE_SHUTDOWN);
        } else {
            return true;
        }
    }
1906 1907
    request = qemu_reset_requested();
    if (request) {
1908
        pause_all_vcpus();
1909
        qemu_system_reset(request);
1910
        resume_all_vcpus();
1911 1912 1913
        if (!runstate_check(RUN_STATE_RUNNING) &&
                !runstate_check(RUN_STATE_INMIGRATE)) {
            runstate_set(RUN_STATE_PRELAUNCH);
1914 1915
        }
    }
1916 1917
    if (qemu_wakeup_requested()) {
        pause_all_vcpus();
1918
        qemu_system_reset(SHUTDOWN_CAUSE_NONE);
L
Liu, Jinsong 已提交
1919 1920
        notifier_list_notify(&wakeup_notifiers, &wakeup_reason);
        wakeup_reason = QEMU_WAKEUP_REASON_NONE;
1921
        resume_all_vcpus();
W
Wenchao Xia 已提交
1922
        qapi_event_send_wakeup(&error_abort);
1923
    }
1924
    if (qemu_powerdown_requested()) {
1925
        qemu_system_powerdown();
1926 1927 1928 1929 1930 1931 1932
    }
    if (qemu_vmstop_requested(&r)) {
        vm_stop(r);
    }
    return false;
}

1933 1934
static void main_loop(void)
{
1935 1936 1937
#ifdef CONFIG_PROFILER
    int64_t ti;
#endif
1938
    do {
1939
#ifdef CONFIG_PROFILER
J
Jan Kiszka 已提交
1940
        ti = profile_getclock();
1941
#endif
1942
        main_loop_wait(false);
1943
#ifdef CONFIG_PROFILER
J
Jan Kiszka 已提交
1944
        dev_time += profile_getclock() - ti;
1945
#endif
1946
    } while (!main_loop_should_exit());
B
bellard 已提交
1947 1948
}

P
pbrook 已提交
1949 1950
static void version(void)
{
1951
    printf("QEMU emulator version " QEMU_VERSION QEMU_PKGVERSION "\n"
1952
           QEMU_COPYRIGHT "\n");
P
pbrook 已提交
1953 1954
}

1955
static void help(int exitcode)
1956
{
1957 1958 1959 1960 1961
    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());

1962 1963
#define QEMU_OPTIONS_GENERATE_HELP
#include "qemu-options-wrapper.h"
1964 1965

    printf("\nDuring emulation, the following keys are useful:\n"
1966 1967 1968 1969
           "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"
1970 1971 1972
           "When using -nographic, press 'ctrl-a h' to get some help.\n"
           "\n"
           QEMU_HELP_BOTTOM "\n");
1973

1974
    exit(exitcode);
1975 1976
}

1977 1978 1979 1980 1981 1982
#define HAS_ARG 0x0001

typedef struct QEMUOption {
    const char *name;
    int flags;
    int index;
1983
    uint32_t arch_mask;
1984 1985
} QEMUOption;

B
blueswir1 已提交
1986
static const QEMUOption qemu_options[] = {
1987
    { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
1988 1989
#define QEMU_OPTIONS_GENERATE_OPTIONS
#include "qemu-options-wrapper.h"
1990
    { NULL },
B
bellard 已提交
1991
};
B
Blue Swirl 已提交
1992

1993 1994 1995
typedef struct VGAInterfaceInfo {
    const char *opt_name;    /* option name */
    const char *name;        /* human-readable name */
1996 1997 1998
    /* Class names indicating that support is available.
     * If no class is specified, the interface is always available */
    const char *class_names[2];
1999 2000 2001 2002 2003 2004 2005 2006 2007
} VGAInterfaceInfo;

static VGAInterfaceInfo vga_interfaces[VGA_TYPE_MAX] = {
    [VGA_NONE] = {
        .opt_name = "none",
    },
    [VGA_STD] = {
        .opt_name = "std",
        .name = "standard VGA",
2008
        .class_names = { "VGA", "isa-vga" },
2009 2010 2011 2012
    },
    [VGA_CIRRUS] = {
        .opt_name = "cirrus",
        .name = "Cirrus VGA",
2013
        .class_names = { "cirrus-vga", "isa-cirrus-vga" },
2014 2015 2016 2017
    },
    [VGA_VMWARE] = {
        .opt_name = "vmware",
        .name = "VMWare SVGA",
2018
        .class_names = { "vmware-svga" },
2019 2020 2021 2022
    },
    [VGA_VIRTIO] = {
        .opt_name = "virtio",
        .name = "Virtio VGA",
2023
        .class_names = { "virtio-vga" },
2024 2025 2026 2027
    },
    [VGA_QXL] = {
        .opt_name = "qxl",
        .name = "QXL VGA",
2028
        .class_names = { "qxl-vga" },
2029 2030 2031 2032
    },
    [VGA_TCX] = {
        .opt_name = "tcx",
        .name = "TCX framebuffer",
2033
        .class_names = { "SUNW,tcx" },
2034 2035 2036 2037
    },
    [VGA_CG3] = {
        .opt_name = "cg3",
        .name = "CG3 framebuffer",
2038
        .class_names = { "cgthree" },
2039 2040 2041 2042 2043 2044
    },
    [VGA_XENFB] = {
        .opt_name = "xenfb",
    },
};

2045 2046 2047 2048 2049 2050 2051 2052 2053 2054
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]);
}

2055
static void select_vgahw(const char *p)
2056 2057
{
    const char *opts;
2058
    int t;
2059

2060
    assert(vga_interface_type == VGA_NONE);
2061 2062 2063
    for (t = 0; t < VGA_TYPE_MAX; t++) {
        VGAInterfaceInfo *ti = &vga_interfaces[t];
        if (ti->opt_name && strstart(p, ti->opt_name, &opts)) {
2064
            if (!vga_interface_available(t)) {
2065 2066 2067 2068 2069
                error_report("%s not available", ti->name);
                exit(1);
            }
            vga_interface_type = t;
            break;
2070
        }
2071 2072
    }
    if (t == VGA_TYPE_MAX) {
2073
    invalid_vga:
2074
        error_report("unknown vga type: %s", p);
2075 2076
        exit(1);
    }
2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
    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;
    }
2090 2091
}

2092
static void parse_display(const char *p)
2093 2094 2095 2096
{
    const char *opts;

    if (strstart(p, "sdl", &opts)) {
G
Gerd Hoffmann 已提交
2097
        dpy.type = DISPLAY_TYPE_SDL;
2098 2099 2100 2101
        while (*opts) {
            const char *nextopt;

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

            if (strstart(opts, ",grab_on_hover=", &nextopt)) {
                opts = nextopt;
2175
                dpy.u.gtk.has_grab_on_hover = true;
2176
                if (strstart(opts, "on", &nextopt)) {
2177
                    dpy.u.gtk.grab_on_hover = true;
2178
                } else if (strstart(opts, "off", &nextopt)) {
2179
                    dpy.u.gtk.grab_on_hover = false;
2180 2181 2182
                } else {
                    goto invalid_gtk_args;
                }
2183 2184
            } else if (strstart(opts, ",gl=", &nextopt)) {
                opts = nextopt;
2185
                dpy.has_gl = true;
2186
                if (strstart(opts, "on", &nextopt)) {
2187
                    dpy.gl = true;
2188
                } else if (strstart(opts, "off", &nextopt)) {
2189
                    dpy.gl = false;
2190 2191 2192
                } else {
                    goto invalid_gtk_args;
                }
2193 2194
            } else {
            invalid_gtk_args:
2195
                error_report("invalid GTK option string");
2196 2197 2198 2199
                exit(1);
            }
            opts = nextopt;
        }
J
Jes Sorensen 已提交
2200
    } else if (strstart(p, "none", &opts)) {
2201
        dpy.type = DISPLAY_TYPE_NONE;
2202
    } else {
2203
        error_report("unknown display type");
2204 2205 2206 2207
        exit(1);
    }
}

2208 2209
static int balloon_parse(const char *arg)
{
2210
    QemuOpts *opts;
2211

2212 2213 2214 2215 2216 2217 2218
    if (strcmp(arg, "none") == 0) {
        return 0;
    }

    if (!strncmp(arg, "virtio", 6)) {
        if (arg[6] == ',') {
            /* have params -> parse them */
2219 2220
            opts = qemu_opts_parse_noisily(qemu_find_opts("device"), arg + 7,
                                           false);
2221 2222 2223 2224
            if (!opts)
                return  -1;
        } else {
            /* create empty opts */
2225 2226
            opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                    &error_abort);
2227
        }
2228
        qemu_opt_set(opts, "driver", "virtio-balloon", &error_abort);
2229
        return 0;
2230
    }
2231 2232

    return -1;
2233 2234
}

P
Paul Brook 已提交
2235 2236
char *qemu_find_file(int type, const char *name)
{
2237
    int i;
P
Paul Brook 已提交
2238 2239 2240
    const char *subdir;
    char *buf;

2241 2242
    /* Try the name as a straight path first */
    if (access(name, R_OK) == 0) {
2243
        trace_load_file(name, name);
2244
        return g_strdup(name);
P
Paul Brook 已提交
2245
    }
2246

P
Paul Brook 已提交
2247 2248 2249 2250 2251 2252 2253 2254 2255 2256
    switch (type) {
    case QEMU_FILE_TYPE_BIOS:
        subdir = "";
        break;
    case QEMU_FILE_TYPE_KEYMAP:
        subdir = "keymaps/";
        break;
    default:
        abort();
    }
2257 2258 2259 2260 2261 2262 2263

    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;
        }
2264
        g_free(buf);
P
Paul Brook 已提交
2265
    }
2266
    return NULL;
P
Paul Brook 已提交
2267 2268
}

G
Gerd Hoffmann 已提交
2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283
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 */
        }
    }
2284
    data_dir[data_dir_idx++] = g_strdup(path);
G
Gerd Hoffmann 已提交
2285 2286
}

2287 2288 2289 2290 2291
static inline bool nonempty_str(const char *str)
{
    return str && *str;
}

2292 2293 2294 2295
static int parse_fw_cfg(void *opaque, QemuOpts *opts, Error **errp)
{
    gchar *buf;
    size_t size;
2296
    const char *name, *file, *str;
2297
    FWCfgState *fw_cfg = (FWCfgState *) opaque;
2298

2299
    if (fw_cfg == NULL) {
2300 2301 2302 2303 2304
        error_report("fw_cfg device not available");
        return -1;
    }
    name = qemu_opt_get(opts, "name");
    file = qemu_opt_get(opts, "file");
2305 2306 2307 2308 2309 2310 2311 2312 2313
    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)))) {
        error_report("invalid argument(s)");
        return -1;
    }
    if (nonempty_str(file) && nonempty_str(str)) {
        error_report("file and string are mutually exclusive");
2314 2315 2316 2317 2318 2319 2320
        return -1;
    }
    if (strlen(name) > FW_CFG_MAX_FILE_PATH - 1) {
        error_report("name too long (max. %d char)", FW_CFG_MAX_FILE_PATH - 1);
        return -1;
    }
    if (strncmp(name, "opt/", 4) != 0) {
2321 2322
        warn_report("externally provided fw_cfg item names "
                    "should be prefixed with \"opt/\"");
2323
    }
2324 2325 2326 2327 2328 2329 2330 2331
    if (nonempty_str(str)) {
        size = strlen(str); /* NUL terminator NOT included in fw_cfg blob */
        buf = g_memdup(str, size);
    } else {
        if (!g_file_get_contents(file, &buf, &size, NULL)) {
            error_report("can't load %s", file);
            return -1;
        }
2332
    }
2333 2334 2335 2336
    /* 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);
2337 2338 2339
    return 0;
}

2340
static int device_help_func(void *opaque, QemuOpts *opts, Error **errp)
2341 2342 2343 2344
{
    return qdev_device_help(opts);
}

2345
static int device_init_func(void *opaque, QemuOpts *opts, Error **errp)
2346
{
2347
    Error *err = NULL;
2348 2349
    DeviceState *dev;

2350 2351 2352
    dev = qdev_device_add(opts, &err);
    if (!dev) {
        error_report_err(err);
2353
        return -1;
2354
    }
2355
    object_unref(OBJECT(dev));
2356 2357 2358
    return 0;
}

2359
static int chardev_init_func(void *opaque, QemuOpts *opts, Error **errp)
2360
{
2361
    Error *local_err = NULL;
2362

2363 2364 2365 2366 2367 2368
    if (!qemu_chr_new_from_opts(opts, &local_err)) {
        if (local_err) {
            error_report_err(local_err);
            return -1;
        }
        exit(0);
2369
    }
2370 2371 2372
    return 0;
}

2373
#ifdef CONFIG_VIRTFS
2374
static int fsdev_init_func(void *opaque, QemuOpts *opts, Error **errp)
2375
{
2376
    return qemu_fsdev_add(opts);
2377 2378 2379
}
#endif

2380
static int mon_init_func(void *opaque, QemuOpts *opts, Error **errp)
2381
{
2382
    Chardev *chr;
2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395
    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 {
2396
        error_report("unknown monitor mode \"%s\"", mode);
2397 2398 2399
        exit(1);
    }

2400 2401 2402
    if (qemu_opt_get_bool(opts, "pretty", 0))
        flags |= MONITOR_USE_PRETTY;

2403 2404 2405
    chardev = qemu_opt_get(opts, "chardev");
    chr = qemu_chr_find(chardev);
    if (chr == NULL) {
2406
        error_report("chardev \"%s\" not found", chardev);
2407 2408 2409 2410 2411 2412 2413
        exit(1);
    }

    monitor_init(chr, flags);
    return 0;
}

M
Max Reitz 已提交
2414
static void monitor_parse(const char *optarg, const char *mode, bool pretty)
2415 2416 2417 2418 2419 2420 2421 2422 2423
{
    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 {
2424 2425
        snprintf(label, sizeof(label), "compat_monitor%d",
                 monitor_device_index);
2426 2427
        opts = qemu_chr_parse_compat(label, optarg);
        if (!opts) {
2428
            error_report("parse error: %s", optarg);
2429 2430 2431 2432
            exit(1);
        }
    }

2433
    opts = qemu_opts_create(qemu_find_opts("mon"), label, 1, &error_fatal);
2434 2435
    qemu_opt_set(opts, "mode", mode, &error_abort);
    qemu_opt_set(opts, "chardev", label, &error_abort);
2436
    qemu_opt_set_bool(opts, "pretty", pretty, &error_abort);
2437 2438 2439
    monitor_device_index++;
}

2440 2441
struct device_config {
    enum {
2442 2443 2444 2445 2446
        DEV_USB,       /* -usbdevice     */
        DEV_BT,        /* -bt            */
        DEV_SERIAL,    /* -serial        */
        DEV_PARALLEL,  /* -parallel      */
        DEV_VIRTCON,   /* -virtioconsole */
2447
        DEV_DEBUGCON,  /* -debugcon */
2448
        DEV_GDB,       /* -gdb, -s */
2449
        DEV_SCLP,      /* s390 sclp */
2450 2451
    } type;
    const char *cmdline;
2452
    Location loc;
2453
    QTAILQ_ENTRY(device_config) next;
2454
};
B
Blue Swirl 已提交
2455 2456 2457

static QTAILQ_HEAD(, device_config) device_configs =
    QTAILQ_HEAD_INITIALIZER(device_configs);
2458 2459 2460 2461 2462

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

2463
    conf = g_malloc0(sizeof(*conf));
2464 2465
    conf->type = type;
    conf->cmdline = cmdline;
2466
    loc_save(&conf->loc);
2467
    QTAILQ_INSERT_TAIL(&device_configs, conf, next);
2468 2469 2470 2471 2472 2473 2474
}

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

2475
    QTAILQ_FOREACH(conf, &device_configs, next) {
2476 2477
        if (conf->type != type)
            continue;
2478
        loc_push_restore(&conf->loc);
2479
        rc = func(conf->cmdline);
2480
        loc_pop(&conf->loc);
G
Gonglei 已提交
2481
        if (rc) {
2482
            return rc;
G
Gonglei 已提交
2483
        }
2484 2485 2486 2487
    }
    return 0;
}

2488 2489 2490 2491 2492 2493 2494 2495
static int serial_parse(const char *devname)
{
    static int index = 0;
    char label[32];

    if (strcmp(devname, "none") == 0)
        return 0;
    if (index == MAX_SERIAL_PORTS) {
2496
        error_report("too many serial ports");
2497 2498 2499
        exit(1);
    }
    snprintf(label, sizeof(label), "serial%d", index);
2500
    serial_hds[index] = qemu_chr_new(label, devname);
2501
    if (!serial_hds[index]) {
2502 2503
        error_report("could not connect serial device"
                     " to character backend '%s'", devname);
2504 2505 2506 2507 2508 2509
        return -1;
    }
    index++;
    return 0;
}

2510 2511 2512 2513 2514 2515 2516 2517
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) {
2518
        error_report("too many parallel ports");
2519 2520 2521
        exit(1);
    }
    snprintf(label, sizeof(label), "parallel%d", index);
2522
    parallel_hds[index] = qemu_chr_new(label, devname);
2523
    if (!parallel_hds[index]) {
2524 2525
        error_report("could not connect parallel device"
                     " to character backend '%s'", devname);
2526 2527 2528 2529 2530 2531
        return -1;
    }
    index++;
    return 0;
}

2532 2533
static int virtcon_parse(const char *devname)
{
2534
    QemuOptsList *device = qemu_find_opts("device");
2535 2536
    static int index = 0;
    char label[32];
2537
    QemuOpts *bus_opts, *dev_opts;
2538 2539 2540 2541

    if (strcmp(devname, "none") == 0)
        return 0;
    if (index == MAX_VIRTIO_CONSOLES) {
2542
        error_report("too many virtio consoles");
2543 2544
        exit(1);
    }
2545

2546
    bus_opts = qemu_opts_create(device, NULL, 0, &error_abort);
2547
    qemu_opt_set(bus_opts, "driver", "virtio-serial", &error_abort);
2548

2549
    dev_opts = qemu_opts_create(device, NULL, 0, &error_abort);
2550
    qemu_opt_set(dev_opts, "driver", "virtconsole", &error_abort);
2551

2552
    snprintf(label, sizeof(label), "virtcon%d", index);
2553
    virtcon_hds[index] = qemu_chr_new(label, devname);
2554
    if (!virtcon_hds[index]) {
2555 2556
        error_report("could not connect virtio console"
                     " to character backend '%s'", devname);
2557 2558
        return -1;
    }
2559
    qemu_opt_set(dev_opts, "chardev", label, &error_abort);
2560

2561 2562 2563 2564
    index++;
    return 0;
}

2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575
static int sclp_parse(const char *devname)
{
    QemuOptsList *device = qemu_find_opts("device");
    static int index = 0;
    char label[32];
    QemuOpts *dev_opts;

    if (strcmp(devname, "none") == 0) {
        return 0;
    }
    if (index == MAX_SCLP_CONSOLES) {
2576
        error_report("too many sclp consoles");
2577 2578 2579 2580 2581 2582
        exit(1);
    }

    assert(arch_type == QEMU_ARCH_S390X);

    dev_opts = qemu_opts_create(device, NULL, 0, NULL);
2583
    qemu_opt_set(dev_opts, "driver", "sclpconsole", &error_abort);
2584 2585

    snprintf(label, sizeof(label), "sclpcon%d", index);
2586
    sclp_hds[index] = qemu_chr_new(label, devname);
2587
    if (!sclp_hds[index]) {
2588 2589
        error_report("could not connect sclp console"
                     " to character backend '%s'", devname);
2590 2591
        return -1;
    }
2592
    qemu_opt_set(dev_opts, "chardev", label, &error_abort);
2593 2594 2595 2596 2597

    index++;
    return 0;
}

2598
static int debugcon_parse(const char *devname)
L
Laszlo Ersek 已提交
2599
{
2600 2601
    QemuOpts *opts;

2602
    if (!qemu_chr_new("debugcon", devname)) {
2603 2604
        exit(1);
    }
2605
    opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL);
2606
    if (!opts) {
2607
        error_report("already have a debugcon device");
2608 2609
        exit(1);
    }
2610 2611
    qemu_opt_set(opts, "driver", "isa-debugcon", &error_abort);
    qemu_opt_set(opts, "chardev", "debugcon", &error_abort);
2612 2613 2614
    return 0;
}

2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649
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)
2650
{
2651
    MachineClass *mc = NULL;
2652
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
2653 2654

    if (name) {
2655
        mc = find_machine(name);
2656
    }
2657
    if (mc) {
2658
        g_slist_free(machines);
2659
        return mc;
2660
    }
2661
    if (name && !is_help_option(name)) {
2662
        error_report("unsupported machine type");
2663
        error_printf("Use -machine help to list supported machines\n");
2664 2665
    } else {
        printf("Supported machines are:\n");
2666
        machines = g_slist_sort(machines, machine_class_cmp);
2667 2668
        for (el = machines; el; el = el->next) {
            MachineClass *mc = el->data;
2669 2670
            if (mc->alias) {
                printf("%-20s %s (alias of %s)\n", mc->alias, mc->desc, mc->name);
2671
            }
2672 2673
            printf("%-20s %s%s\n", mc->name, mc->desc,
                   mc->is_default ? " (default)" : "");
2674 2675
        }
    }
2676 2677

    g_slist_free(machines);
2678
    exit(!name || !is_help_option(name));
2679 2680
}

G
Gerd Hoffmann 已提交
2681 2682 2683 2684 2685 2686 2687
void qemu_add_exit_notifier(Notifier *notify)
{
    notifier_list_add(&exit_notifiers, notify);
}

void qemu_remove_exit_notifier(Notifier *notify)
{
P
Paolo Bonzini 已提交
2688
    notifier_remove(notify);
G
Gerd Hoffmann 已提交
2689 2690 2691 2692
}

static void qemu_run_exit_notifiers(void)
{
2693
    notifier_list_notify(&exit_notifiers, NULL);
G
Gerd Hoffmann 已提交
2694 2695
}

2696 2697
static bool machine_init_done;

2698 2699 2700
void qemu_add_machine_init_done_notifier(Notifier *notify)
{
    notifier_list_add(&machine_init_done_notifiers, notify);
2701 2702 2703
    if (machine_init_done) {
        notify->notify(notify, NULL);
    }
2704 2705
}

2706 2707 2708 2709 2710
void qemu_remove_machine_init_done_notifier(Notifier *notify)
{
    notifier_remove(notify);
}

2711 2712
static void qemu_run_machine_init_done_notifiers(void)
{
2713
    notifier_list_notify(&machine_init_done_notifiers, NULL);
2714
    machine_init_done = true;
2715 2716
}

2717 2718 2719 2720 2721 2722 2723 2724
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;

2725
    loc_set_cmdline(argv, optind, 1);
2726 2727 2728 2729 2730 2731 2732
    optind++;
    /* Treat --foo the same as -foo.  */
    if (r[1] == '-')
        r++;
    popt = qemu_options;
    for(;;) {
        if (!popt->name) {
2733
            error_report("invalid option");
2734 2735 2736 2737 2738 2739 2740 2741
            exit(1);
        }
        if (!strcmp(popt->name, r + 1))
            break;
        popt++;
    }
    if (popt->flags & HAS_ARG) {
        if (optind >= argc) {
2742
            error_report("requires an argument");
2743 2744 2745
            exit(1);
        }
        optarg = argv[optind++];
2746
        loc_set_cmdline(argv, optind - 2, 2);
2747 2748 2749 2750 2751 2752 2753 2754 2755 2756
    } else {
        optarg = NULL;
    }

    *poptarg = optarg;
    *poptind = optind;

    return popt;
}

2757
static MachineClass *select_machine(void)
2758
{
2759
    MachineClass *machine_class = find_default_machine();
2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770
    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) {
2771
        machine_class = machine_parse(optarg);
2772 2773
    }

2774
    if (!machine_class) {
2775 2776 2777 2778 2779 2780
        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);
2781
    return machine_class;
2782 2783
}

2784 2785 2786
static int machine_set_property(void *opaque,
                                const char *name, const char *value,
                                Error **errp)
2787 2788 2789
{
    Object *obj = OBJECT(opaque);
    Error *local_err = NULL;
2790
    char *p, *qom_name;
2791

2792
    if (strcmp(name, "type") == 0) {
2793 2794 2795
        return 0;
    }

2796
    qom_name = g_strdup(name);
2797 2798 2799
    for (p = qom_name; *p; p++) {
        if (*p == '_') {
            *p = '-';
2800 2801 2802
        }
    }

2803
    object_property_parse(obj, value, qom_name, &local_err);
2804
    g_free(qom_name);
2805 2806

    if (local_err) {
2807
        error_report_err(local_err);
2808 2809 2810 2811 2812 2813
        return -1;
    }

    return 0;
}

2814 2815 2816 2817 2818 2819 2820 2821 2822 2823

/*
 * 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.
 */
static bool object_create_initial(const char *type)
{
2824 2825
    if (g_str_equal(type, "rng-egd") ||
        g_str_has_prefix(type, "pr-manager-")) {
2826 2827
        return false;
    }
2828

2829 2830 2831 2832 2833 2834
#if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
    if (g_str_equal(type, "cryptodev-vhost-user")) {
        return false;
    }
#endif

2835 2836 2837 2838 2839
    /*
     * return false for concrete netfilters since
     * they depend on netdevs already existing
     */
    if (g_str_equal(type, "filter-buffer") ||
2840
        g_str_equal(type, "filter-dump") ||
2841
        g_str_equal(type, "filter-mirror") ||
2842
        g_str_equal(type, "filter-redirector") ||
2843
        g_str_equal(type, "colo-compare") ||
2844 2845
        g_str_equal(type, "filter-rewriter") ||
        g_str_equal(type, "filter-replay")) {
2846 2847 2848
        return false;
    }

2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861
    /* 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;
    }

2862 2863 2864 2865 2866 2867
    return true;
}


/*
 * The remainder of object creation happens after the
2868
 * creation of chardev, fsdev, net clients and device data types.
2869 2870 2871 2872 2873 2874 2875
 */
static bool object_create_delayed(const char *type)
{
    return !object_create_initial(type);
}


2876 2877
static void set_memory_options(uint64_t *ram_slots, ram_addr_t *maxram_size,
                               MachineClass *mc)
2878 2879 2880 2881
{
    uint64_t sz;
    const char *mem_str;
    const char *maxmem_str, *slots_str;
2882
    const ram_addr_t default_ram_size = mc->default_ram_size;
2883
    QemuOpts *opts = qemu_find_opts_singleton("memory");
2884 2885 2886 2887
    Location loc;

    loc_push_none(&loc);
    qemu_opts_loc_restore(opts);
2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923

    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;

            sz <<= 20;
            if ((sz >> 20) != overflow_check) {
                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 */
2924
    qemu_opt_set_number(opts, "size", ram_size, &error_abort);
2925 2926 2927 2928 2929 2930 2931 2932
    *maxram_size = ram_size;

    maxmem_str = qemu_opt_get(opts, "maxmem");
    slots_str = qemu_opt_get(opts, "slots");
    if (maxmem_str && slots_str) {
        uint64_t slots;

        sz = qemu_opt_get_size(opts, "maxmem", 0);
2933
        slots = qemu_opt_get_number(opts, "slots", 0);
2934
        if (sz < ram_size) {
2935 2936 2937 2938
            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);
2939
            exit(EXIT_FAILURE);
2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950
        } else if (sz > ram_size) {
            if (!slots) {
                error_report("invalid value of -m option: maxmem was "
                             "specified, but no hotplug slots were specified");
                exit(EXIT_FAILURE);
            }
        } else if (slots) {
            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);
2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961
            exit(EXIT_FAILURE);
        }

        *maxram_size = sz;
        *ram_slots = slots;
    } else if ((!maxmem_str && slots_str) ||
            (maxmem_str && !slots_str)) {
        error_report("invalid -m option value: missing "
                "'%s' option", slots_str ? "maxmem" : "slots");
        exit(EXIT_FAILURE);
    }
2962 2963

    loc_pop(&loc);
2964 2965
}

2966 2967 2968 2969 2970 2971 2972 2973 2974
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;
2975
    g->errp = &error_fatal;
2976 2977 2978 2979
    qdev_prop_register_global(g);
    return 0;
}

2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991
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;
}

2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010
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 已提交
3011
int main(int argc, char **argv, char **envp)
3012
{
3013
    int i;
3014
    int snapshot, linux_boot;
3015
    const char *initrd_filename;
3016
    const char *kernel_filename, *kernel_cmdline;
3017 3018
    const char *boot_order = NULL;
    const char *boot_once = NULL;
3019
    DisplayState *ds;
3020
    QemuOpts *opts, *machine_opts;
3021
    QemuOpts *icount_opts = NULL, *accel_opts = NULL;
3022
    QemuOptsList *olist;
3023
    int optind;
3024
    const char *optarg;
3025
    const char *loadvm = NULL;
3026
    MachineClass *machine_class;
3027
    const char *cpu_model;
3028
    const char *vga_model = NULL;
3029 3030
    const char *qtest_chrdev = NULL;
    const char *qtest_log = NULL;
3031
    const char *pid_file = NULL;
3032
    const char *incoming = NULL;
3033
    bool userconfig = true;
3034
    bool nographic = false;
3035
    int display_remote = 0;
3036 3037
    const char *log_mask = NULL;
    const char *log_file = NULL;
3038
    char *trace_file = NULL;
3039
    ram_addr_t maxram_size;
3040
    uint64_t ram_slots = 0;
3041
    FILE *vmstate_dump_file = NULL;
3042
    Error *main_loop_err = NULL;
3043
    Error *err = NULL;
3044
    bool list_data_dirs = false;
3045
    char *dir, **dirs;
3046 3047 3048 3049 3050 3051 3052
    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);
3053

3054 3055
    module_call_init(MODULE_INIT_TRACE);

3056
    qemu_init_cpu_list();
3057 3058 3059
    qemu_init_cpu_loop();
    qemu_mutex_lock_iothread();

G
Gerd Hoffmann 已提交
3060
    atexit(qemu_run_exit_notifiers);
3061
    error_set_progname(argv[0]);
3062
    qemu_init_exec_dir(argv[0]);
3063

3064
    module_call_init(MODULE_INIT_QOM);
3065
    monitor_init_qmp_commands();
3066

3067
    qemu_add_opts(&qemu_drive_opts);
3068 3069 3070
    qemu_add_drive_opts(&qemu_legacy_drive_opts);
    qemu_add_drive_opts(&qemu_common_drive_opts);
    qemu_add_drive_opts(&qemu_drive_opts);
3071
    qemu_add_drive_opts(&bdrv_runtime_opts);
3072 3073 3074
    qemu_add_opts(&qemu_chardev_opts);
    qemu_add_opts(&qemu_device_opts);
    qemu_add_opts(&qemu_netdev_opts);
3075
    qemu_add_opts(&qemu_nic_opts);
3076 3077 3078 3079 3080 3081 3082
    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);
3083
    qemu_add_opts(&qemu_accel_opts);
3084
    qemu_add_opts(&qemu_mem_opts);
3085
    qemu_add_opts(&qemu_smp_opts);
3086 3087 3088 3089
    qemu_add_opts(&qemu_boot_opts);
    qemu_add_opts(&qemu_sandbox_opts);
    qemu_add_opts(&qemu_add_fd_opts);
    qemu_add_opts(&qemu_object_opts);
3090
    qemu_add_opts(&qemu_tpmdev_opts);
3091
    qemu_add_opts(&qemu_realtime_opts);
3092
    qemu_add_opts(&qemu_msg_opts);
3093
    qemu_add_opts(&qemu_name_opts);
3094
    qemu_add_opts(&qemu_numa_opts);
3095
    qemu_add_opts(&qemu_icount_opts);
3096
    qemu_add_opts(&qemu_semihosting_config_opts);
3097
    qemu_add_opts(&qemu_fw_cfg_opts);
3098
    module_call_init(MODULE_INIT_OPTS);
3099

3100 3101
    runstate_init();

3102
    if (qcrypto_init(&err) < 0) {
3103
        error_reportf_err(err, "cannot initialize crypto: ");
3104 3105
        exit(1);
    }
3106
    rtc_clock = QEMU_CLOCK_HOST;
J
Jan Kiszka 已提交
3107

3108
    QLIST_INIT (&vm_change_state_head);
3109
    os_setup_early_signal_handling();
3110

3111
    cpu_model = NULL;
3112
    snapshot = 0;
3113

B
bellard 已提交
3114
    nb_nics = 0;
3115

3116 3117
    bdrv_init_with_whitelist();

3118
    autostart = 1;
3119

3120 3121 3122 3123 3124
    /* first pass of option parsing */
    optind = 1;
    while (optind < argc) {
        if (argv[optind][0] != '-') {
            /* disk image */
3125
            optind++;
3126 3127 3128 3129 3130 3131
        } else {
            const QEMUOption *popt;

            popt = lookup_opt(argc, argv, &optarg, &optind);
            switch (popt->index) {
            case QEMU_OPTION_nodefconfig:
3132 3133 3134
            case QEMU_OPTION_nouserconfig:
                userconfig = false;
                break;
3135 3136 3137 3138
            }
        }
    }

3139
    if (userconfig) {
3140
        if (qemu_read_default_config_file() < 0) {
3141
            exit(1);
3142 3143 3144 3145
        }
    }

    /* second pass of option parsing */
3146
    optind = 1;
3147
    for(;;) {
3148
        if (optind >= argc)
3149
            break;
3150
        if (argv[optind][0] != '-') {
3151
            drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
3152 3153 3154
        } else {
            const QEMUOption *popt;

3155
            popt = lookup_opt(argc, argv, &optarg, &optind);
3156
            if (!(popt->arch_mask & arch_type)) {
3157
                error_report("Option not supported for this target");
3158 3159
                exit(1);
            }
3160
            switch(popt->index) {
3161 3162
            case QEMU_OPTION_no_kvm_irqchip: {
                olist = qemu_find_opts("machine");
3163
                qemu_opts_parse_noisily(olist, "kernel_irqchip=off", false);
3164 3165
                break;
            }
3166 3167
            case QEMU_OPTION_cpu:
                /* hw initialization will check this */
3168
                cpu_model = optarg;
3169
                break;
3170 3171
            case QEMU_OPTION_hda:
            case QEMU_OPTION_hdb:
3172 3173
            case QEMU_OPTION_hdc:
            case QEMU_OPTION_hdd:
3174 3175
                drive_add(IF_DEFAULT, popt->index - QEMU_OPTION_hda, optarg,
                          HD_OPTS);
B
bellard 已提交
3176
                break;
3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195
            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;
                }
3196
            case QEMU_OPTION_drive:
3197 3198 3199
                if (drive_def(optarg) == NULL) {
                    exit(1);
                }
3200
                break;
G
Gerd Hoffmann 已提交
3201 3202 3203
            case QEMU_OPTION_set:
                if (qemu_set_option(optarg) != 0)
                    exit(1);
3204
                break;
3205 3206 3207
            case QEMU_OPTION_global:
                if (qemu_global_option(optarg) != 0)
                    exit(1);
3208
                break;
3209
            case QEMU_OPTION_mtdblock:
3210
                drive_add(IF_MTD, -1, optarg, MTD_OPTS);
3211
                break;
3212
            case QEMU_OPTION_sd:
3213
                drive_add(IF_SD, -1, optarg, SD_OPTS);
3214
                break;
3215
            case QEMU_OPTION_pflash:
3216
                drive_add(IF_PFLASH, -1, optarg, PFLASH_OPTS);
3217
                break;
3218
            case QEMU_OPTION_snapshot:
3219 3220
                snapshot = 1;
                break;
3221
            case QEMU_OPTION_numa:
3222 3223
                opts = qemu_opts_parse_noisily(qemu_find_opts("numa"),
                                               optarg, true);
3224 3225 3226
                if (!opts) {
                    exit(1);
                }
3227
                break;
3228
            case QEMU_OPTION_display:
3229
                parse_display(optarg);
3230
                break;
3231
            case QEMU_OPTION_nographic:
3232 3233 3234
                olist = qemu_find_opts("machine");
                qemu_opts_parse_noisily(olist, "graphics=off", false);
                nographic = true;
3235
                dpy.type = DISPLAY_TYPE_NONE;
3236
                break;
B
balrog 已提交
3237
            case QEMU_OPTION_curses:
3238
#ifdef CONFIG_CURSES
3239
                dpy.type = DISPLAY_TYPE_CURSES;
3240
#else
3241
                error_report("curses support is disabled");
3242
                exit(1);
B
balrog 已提交
3243
#endif
3244
                break;
3245
            case QEMU_OPTION_portrait:
3246 3247 3248 3249 3250 3251
                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) {
3252
                    error_report("only 90, 180, 270 deg rotation is available");
3253 3254
                    exit(1);
                }
3255
                break;
3256
            case QEMU_OPTION_kernel:
3257 3258
                qemu_opts_set(qemu_find_opts("machine"), 0, "kernel", optarg,
                              &error_abort);
3259 3260
                break;
            case QEMU_OPTION_initrd:
3261 3262
                qemu_opts_set(qemu_find_opts("machine"), 0, "initrd", optarg,
                              &error_abort);
3263
                break;
3264
            case QEMU_OPTION_append:
3265 3266
                qemu_opts_set(qemu_find_opts("machine"), 0, "append", optarg,
                              &error_abort);
3267
                break;
3268
            case QEMU_OPTION_dtb:
3269 3270
                qemu_opts_set(qemu_find_opts("machine"), 0, "dtb", optarg,
                              &error_abort);
3271
                break;
3272
            case QEMU_OPTION_cdrom:
3273
                drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS);
3274
                break;
3275
            case QEMU_OPTION_boot:
3276 3277
                opts = qemu_opts_parse_noisily(qemu_find_opts("boot-opts"),
                                               optarg, true);
3278 3279
                if (!opts) {
                    exit(1);
3280 3281
                }
                break;
3282 3283
            case QEMU_OPTION_fda:
            case QEMU_OPTION_fdb:
3284 3285
                drive_add(IF_FLOPPY, popt->index - QEMU_OPTION_fda,
                          optarg, FD_OPTS);
3286
                break;
3287 3288 3289
            case QEMU_OPTION_no_fd_bootchk:
                fd_bootchk = 0;
                break;
M
Mark McLoughlin 已提交
3290
            case QEMU_OPTION_netdev:
3291
                default_net = 0;
3292
                if (net_client_parse(qemu_find_opts("netdev"), optarg) == -1) {
M
Mark McLoughlin 已提交
3293 3294 3295
                    exit(1);
                }
                break;
3296 3297 3298 3299 3300 3301
            case QEMU_OPTION_nic:
                default_net = 0;
                if (net_client_parse(qemu_find_opts("nic"), optarg) == -1) {
                    exit(1);
                }
                break;
B
bellard 已提交
3302
            case QEMU_OPTION_net:
3303
                default_net = 0;
3304
                if (net_client_parse(qemu_find_opts("net"), optarg) == -1) {
3305 3306
                    exit(1);
                }
B
bellard 已提交
3307
                break;
3308 3309
#ifdef CONFIG_LIBISCSI
            case QEMU_OPTION_iscsi:
3310 3311
                opts = qemu_opts_parse_noisily(qemu_find_opts("iscsi"),
                                               optarg, false);
3312 3313 3314 3315 3316
                if (!opts) {
                    exit(1);
                }
                break;
#endif
B
bellard 已提交
3317 3318
#ifdef CONFIG_SLIRP
            case QEMU_OPTION_tftp:
3319 3320
                error_report("The -tftp option is deprecated. "
                             "Please use '-netdev user,tftp=...' instead.");
3321
                legacy_tftp_prefix = optarg;
B
bellard 已提交
3322
                break;
3323
            case QEMU_OPTION_bootp:
3324 3325
                error_report("The -bootp option is deprecated. "
                             "Please use '-netdev user,bootfile=...' instead.");
3326
                legacy_bootp_filename = optarg;
3327
                break;
B
bellard 已提交
3328
            case QEMU_OPTION_redir:
3329 3330
                error_report("The -redir option is deprecated. "
                             "Please use '-netdev user,hostfwd=...' instead.");
3331 3332
                if (net_slirp_redir(optarg) < 0)
                    exit(1);
B
bellard 已提交
3333
                break;
B
bellard 已提交
3334
#endif
3335
            case QEMU_OPTION_bt:
3336
                add_device_config(DEV_BT, optarg);
3337
                break;
3338 3339 3340 3341 3342 3343 3344
            case QEMU_OPTION_audio_help:
                AUD_help ();
                exit (0);
                break;
            case QEMU_OPTION_soundhw:
                select_soundhw (optarg);
                break;
3345
            case QEMU_OPTION_h:
3346
                help(0);
3347
                break;
P
pbrook 已提交
3348 3349 3350 3351
            case QEMU_OPTION_version:
                version();
                exit(0);
                break;
3352
            case QEMU_OPTION_m:
3353 3354
                opts = qemu_opts_parse_noisily(qemu_find_opts("memory"),
                                               optarg, true);
3355 3356 3357
                if (!opts) {
                    exit(EXIT_FAILURE);
                }
3358
                break;
3359 3360 3361 3362 3363 3364 3365
#ifdef CONFIG_TPM
            case QEMU_OPTION_tpmdev:
                if (tpm_config_parse(qemu_find_opts("tpmdev"), optarg) < 0) {
                    exit(1);
                }
                break;
#endif
3366 3367 3368 3369 3370 3371
            case QEMU_OPTION_mempath:
                mem_path = optarg;
                break;
            case QEMU_OPTION_mem_prealloc:
                mem_prealloc = 1;
                break;
3372
            case QEMU_OPTION_d:
3373 3374 3375 3376
                log_mask = optarg;
                break;
            case QEMU_OPTION_D:
                log_file = optarg;
3377
                break;
3378
            case QEMU_OPTION_DFILTER:
3379
                qemu_set_dfilter_ranges(optarg, &error_fatal);
3380
                break;
3381
            case QEMU_OPTION_s:
3382
                add_device_config(DEV_GDB, "tcp::" DEFAULT_GDBSTUB_PORT);
3383
                break;
3384
            case QEMU_OPTION_gdb:
3385
                add_device_config(DEV_GDB, optarg);
3386 3387
                break;
            case QEMU_OPTION_L:
3388 3389
                if (is_help_option(optarg)) {
                    list_data_dirs = true;
G
Gerd Hoffmann 已提交
3390 3391
                } else {
                    qemu_add_data_dir(optarg);
3392
                }
3393
                break;
3394
            case QEMU_OPTION_bios:
3395 3396
                qemu_opts_set(qemu_find_opts("machine"), 0, "firmware", optarg,
                              &error_abort);
3397
                break;
3398 3399 3400
            case QEMU_OPTION_singlestep:
                singlestep = 1;
                break;
3401
            case QEMU_OPTION_S:
3402
                autostart = 0;
3403
                break;
3404 3405 3406
            case QEMU_OPTION_k:
                keyboard_layout = optarg;
                break;
B
bellard 已提交
3407 3408
            case QEMU_OPTION_localtime:
                rtc_utc = 0;
3409 3410
                warn_report("This option is deprecated, "
                            "use '-rtc base=localtime' instead.");
B
bellard 已提交
3411
                break;
3412
            case QEMU_OPTION_vga:
B
Blue Swirl 已提交
3413
                vga_model = optarg;
3414
                default_vga = 0;
3415
                break;
3416 3417 3418 3419 3420 3421 3422 3423
            case QEMU_OPTION_g:
                {
                    const char *p;
                    int w, h, depth;
                    p = optarg;
                    w = strtol(p, (char **)&p, 10);
                    if (w <= 0) {
                    graphic_error:
3424
                        error_report("invalid resolution or depth");
3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435
                        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);
3436
                        if (depth != 8 && depth != 15 && depth != 16 &&
3437 3438 3439 3440 3441 3442 3443
                            depth != 24 && depth != 32)
                            goto graphic_error;
                    } else if (*p == '\0') {
                        depth = graphic_depth;
                    } else {
                        goto graphic_error;
                    }
3444

3445 3446 3447 3448 3449
                    graphic_width = w;
                    graphic_height = h;
                    graphic_depth = depth;
                }
                break;
3450 3451 3452 3453 3454 3455 3456 3457
            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 已提交
3458
            case QEMU_OPTION_monitor:
3459
                default_monitor = 0;
3460
                if (strncmp(optarg, "none", 4)) {
M
Max Reitz 已提交
3461
                    monitor_parse(optarg, "readline", false);
3462
                }
3463 3464
                break;
            case QEMU_OPTION_qmp:
M
Max Reitz 已提交
3465 3466 3467 3468 3469
                monitor_parse(optarg, "control", false);
                default_monitor = 0;
                break;
            case QEMU_OPTION_qmp_pretty:
                monitor_parse(optarg, "control", true);
3470
                default_monitor = 0;
B
bellard 已提交
3471
                break;
G
Gerd Hoffmann 已提交
3472
            case QEMU_OPTION_mon:
3473 3474
                opts = qemu_opts_parse_noisily(qemu_find_opts("mon"), optarg,
                                               true);
G
Gerd Hoffmann 已提交
3475 3476 3477
                if (!opts) {
                    exit(1);
                }
3478
                default_monitor = 0;
G
Gerd Hoffmann 已提交
3479
                break;
3480
            case QEMU_OPTION_chardev:
3481 3482
                opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
                                               optarg, true);
3483 3484 3485 3486
                if (!opts) {
                    exit(1);
                }
                break;
3487
            case QEMU_OPTION_fsdev:
3488 3489
                olist = qemu_find_opts("fsdev");
                if (!olist) {
3490
                    error_report("fsdev support is disabled");
3491 3492
                    exit(1);
                }
3493
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3494 3495 3496 3497
                if (!opts) {
                    exit(1);
                }
                break;
3498
            case QEMU_OPTION_virtfs: {
3499 3500
                QemuOpts *fsdev;
                QemuOpts *device;
3501
                const char *writeout, *sock_fd, *socket, *path, *security_model;
3502

3503 3504
                olist = qemu_find_opts("virtfs");
                if (!olist) {
3505
                    error_report("virtfs support is disabled");
3506 3507
                    exit(1);
                }
3508
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3509 3510 3511 3512
                if (!opts) {
                    exit(1);
                }

3513
                if (qemu_opt_get(opts, "fsdriver") == NULL ||
3514
                    qemu_opt_get(opts, "mount_tag") == NULL) {
3515
                    error_report("Usage: -virtfs fsdriver,mount_tag=tag");
3516 3517
                    exit(1);
                }
3518
                fsdev = qemu_opts_create(qemu_find_opts("fsdev"),
3519
                                         qemu_opts_id(opts) ?:
3520 3521
                                         qemu_opt_get(opts, "mount_tag"),
                                         1, NULL);
3522
                if (!fsdev) {
3523
                    error_report("duplicate or invalid fsdev id: %s",
3524
                                 qemu_opt_get(opts, "mount_tag"));
3525 3526
                    exit(1);
                }
3527 3528 3529 3530

                writeout = qemu_opt_get(opts, "writeout");
                if (writeout) {
#ifdef CONFIG_SYNC_FILE_RANGE
3531
                    qemu_opt_set(fsdev, "writeout", writeout, &error_abort);
3532
#else
3533 3534
                    error_report("writeout=immediate not supported "
                                 "on this platform");
3535 3536 3537
                    exit(1);
#endif
                }
3538 3539
                qemu_opt_set(fsdev, "fsdriver",
                             qemu_opt_get(opts, "fsdriver"), &error_abort);
3540 3541 3542 3543 3544 3545 3546 3547 3548
                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);
                }
3549 3550
                socket = qemu_opt_get(opts, "socket");
                if (socket) {
3551
                    qemu_opt_set(fsdev, "socket", socket, &error_abort);
3552
                }
3553 3554
                sock_fd = qemu_opt_get(opts, "sock_fd");
                if (sock_fd) {
3555
                    qemu_opt_set(fsdev, "sock_fd", sock_fd, &error_abort);
3556
                }
3557

3558
                qemu_opt_set_bool(fsdev, "readonly",
3559 3560
                                  qemu_opt_get_bool(opts, "readonly", 0),
                                  &error_abort);
3561 3562
                device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                          &error_abort);
3563
                qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
3564
                qemu_opt_set(device, "fsdev",
3565
                             qemu_opts_id(fsdev), &error_abort);
3566
                qemu_opt_set(device, "mount_tag",
3567
                             qemu_opt_get(opts, "mount_tag"), &error_abort);
3568 3569
                break;
            }
3570 3571 3572 3573
            case QEMU_OPTION_virtfs_synth: {
                QemuOpts *fsdev;
                QemuOpts *device;

3574 3575
                fsdev = qemu_opts_create(qemu_find_opts("fsdev"), "v_synth",
                                         1, NULL);
3576
                if (!fsdev) {
3577
                    error_report("duplicate option: %s", "virtfs_synth");
3578 3579
                    exit(1);
                }
3580
                qemu_opt_set(fsdev, "fsdriver", "synth", &error_abort);
3581

3582 3583
                device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                          &error_abort);
3584 3585 3586
                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);
3587 3588
                break;
            }
B
bellard 已提交
3589
            case QEMU_OPTION_serial:
3590 3591
                add_device_config(DEV_SERIAL, optarg);
                default_serial = 0;
3592 3593 3594
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
B
bellard 已提交
3595
                break;
R
Richard W.M. Jones 已提交
3596
            case QEMU_OPTION_watchdog:
3597
                if (watchdog) {
3598
                    error_report("only one watchdog option may be given");
3599 3600 3601
                    return 1;
                }
                watchdog = optarg;
R
Richard W.M. Jones 已提交
3602 3603 3604
                break;
            case QEMU_OPTION_watchdog_action:
                if (select_watchdog_action(optarg) == -1) {
3605
                    error_report("unknown -watchdog-action parameter");
R
Richard W.M. Jones 已提交
3606 3607 3608
                    exit(1);
                }
                break;
3609
            case QEMU_OPTION_virtiocon:
3610 3611
                add_device_config(DEV_VIRTCON, optarg);
                default_virtcon = 0;
3612 3613 3614
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
3615
                break;
3616
            case QEMU_OPTION_parallel:
3617 3618
                add_device_config(DEV_PARALLEL, optarg);
                default_parallel = 0;
3619 3620 3621
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
3622
                break;
3623 3624 3625
            case QEMU_OPTION_debugcon:
                add_device_config(DEV_DEBUGCON, optarg);
                break;
3626 3627 3628
            case QEMU_OPTION_loadvm:
                loadvm = optarg;
                break;
3629
            case QEMU_OPTION_full_screen:
3630 3631
                dpy.has_full_screen = true;
                dpy.full_screen = true;
3632
                break;
3633
            case QEMU_OPTION_no_frame:
G
Gerd Hoffmann 已提交
3634 3635
                g_printerr("The -no-frame switch is deprecated, and will be\n"
                           "removed in a future release.\n");
3636 3637
                no_frame = 1;
                break;
3638 3639 3640
            case QEMU_OPTION_alt_grab:
                alt_grab = 1;
                break;
3641 3642 3643
            case QEMU_OPTION_ctrl_grab:
                ctrl_grab = 1;
                break;
3644
            case QEMU_OPTION_no_quit:
3645 3646
                dpy.has_window_close = true;
                dpy.window_close = false;
3647
                break;
3648
            case QEMU_OPTION_sdl:
3649
#ifdef CONFIG_SDL
G
Gerd Hoffmann 已提交
3650
                dpy.type = DISPLAY_TYPE_SDL;
3651
                break;
3652
#else
3653
                error_report("SDL support is disabled");
3654
                exit(1);
3655
#endif
B
bellard 已提交
3656
            case QEMU_OPTION_pidfile:
3657
                pid_file = optarg;
B
bellard 已提交
3658
                break;
3659 3660 3661
            case QEMU_OPTION_win2k_hack:
                win2k_install_hack = 1;
                break;
3662
            case QEMU_OPTION_rtc_td_hack: {
3663 3664 3665 3666
                static GlobalProperty slew_lost_ticks = {
                    .driver   = "mc146818rtc",
                    .property = "lost_tick_policy",
                    .value    = "slew",
3667 3668
                };

3669
                qdev_prop_register_global(&slew_lost_ticks);
3670 3671
                warn_report("This option is deprecated, "
                            "use '-rtc driftfix=slew' instead.");
3672
                break;
3673
            }
3674
            case QEMU_OPTION_acpitable:
3675 3676
                opts = qemu_opts_parse_noisily(qemu_find_opts("acpi"),
                                               optarg, true);
3677 3678 3679
                if (!opts) {
                    exit(1);
                }
3680
                acpi_table_add(opts, &error_fatal);
3681
                break;
3682
            case QEMU_OPTION_smbios:
3683 3684
                opts = qemu_opts_parse_noisily(qemu_find_opts("smbios"),
                                               optarg, false);
3685 3686 3687
                if (!opts) {
                    exit(1);
                }
3688
                smbios_entry_add(opts, &error_fatal);
3689
                break;
3690
            case QEMU_OPTION_fwcfg:
3691 3692
                opts = qemu_opts_parse_noisily(qemu_find_opts("fw_cfg"),
                                               optarg, true);
3693 3694 3695 3696
                if (opts == NULL) {
                    exit(1);
                }
                break;
A
aliguori 已提交
3697
            case QEMU_OPTION_enable_kvm:
3698
                olist = qemu_find_opts("machine");
3699
                qemu_opts_parse_noisily(olist, "accel=kvm", false);
3700
                break;
3701 3702 3703 3704
            case QEMU_OPTION_enable_hax:
                olist = qemu_find_opts("machine");
                qemu_opts_parse_noisily(olist, "accel=hax", false);
                break;
3705
            case QEMU_OPTION_M:
3706 3707
            case QEMU_OPTION_machine:
                olist = qemu_find_opts("machine");
3708
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3709 3710 3711
                if (!opts) {
                    exit(1);
                }
A
aliguori 已提交
3712
                break;
3713 3714
             case QEMU_OPTION_no_kvm:
                olist = qemu_find_opts("machine");
3715
                qemu_opts_parse_noisily(olist, "accel=tcg", false);
3716
                break;
3717
            case QEMU_OPTION_no_kvm_pit_reinjection: {
3718 3719 3720 3721
                static GlobalProperty kvm_pit_lost_tick_policy = {
                    .driver   = "kvm-pit",
                    .property = "lost_tick_policy",
                    .value    = "discard",
3722 3723
                };

3724 3725
                warn_report("deprecated, replaced by "
                            "-global kvm-pit.lost_tick_policy=discard");
3726
                qdev_prop_register_global(&kvm_pit_lost_tick_policy);
3727 3728
                break;
            }
3729
            case QEMU_OPTION_accel:
3730 3731 3732
                accel_opts = qemu_opts_parse_noisily(qemu_find_opts("accel"),
                                                     optarg, true);
                optarg = qemu_opt_get(accel_opts, "accel");
3733 3734
                if (!optarg || is_help_option(optarg)) {
                    error_printf("Possible accelerators: kvm, xen, hax, tcg\n");
3735
                    exit(0);
3736
                }
3737 3738 3739
                opts = qemu_opts_create(qemu_find_opts("machine"), NULL,
                                        false, &error_abort);
                qemu_opt_set(opts, "accel", optarg, &error_abort);
3740
                break;
B
bellard 已提交
3741
            case QEMU_OPTION_usb:
3742
                olist = qemu_find_opts("machine");
3743
                qemu_opts_parse_noisily(olist, "usb=on", false);
B
bellard 已提交
3744
                break;
B
bellard 已提交
3745
            case QEMU_OPTION_usbdevice:
3746 3747
                error_report("'-usbdevice' is deprecated, please use "
                             "'-device usb-...' instead");
3748
                olist = qemu_find_opts("machine");
3749
                qemu_opts_parse_noisily(olist, "usb=on", false);
3750 3751 3752
                add_device_config(DEV_USB, optarg);
                break;
            case QEMU_OPTION_device:
3753 3754
                if (!qemu_opts_parse_noisily(qemu_find_opts("device"),
                                             optarg, true)) {
3755 3756
                    exit(1);
                }
B
bellard 已提交
3757
                break;
B
bellard 已提交
3758
            case QEMU_OPTION_smp:
3759 3760
                if (!qemu_opts_parse_noisily(qemu_find_opts("smp-opts"),
                                             optarg, true)) {
3761 3762
                    exit(1);
                }
B
bellard 已提交
3763
                break;
3764
            case QEMU_OPTION_vnc:
3765
                vnc_parse(optarg, &error_fatal);
J
Jes Sorensen 已提交
3766
                break;
B
bellard 已提交
3767 3768 3769
            case QEMU_OPTION_no_acpi:
                acpi_enabled = 0;
                break;
3770 3771 3772
            case QEMU_OPTION_no_hpet:
                no_hpet = 1;
                break;
3773 3774
            case QEMU_OPTION_balloon:
                if (balloon_parse(optarg) < 0) {
3775
                    error_report("unknown -balloon argument %s", optarg);
3776 3777
                    exit(1);
                }
3778
                break;
B
bellard 已提交
3779 3780 3781
            case QEMU_OPTION_no_reboot:
                no_reboot = 1;
                break;
A
aurel32 已提交
3782 3783 3784
            case QEMU_OPTION_no_shutdown:
                no_shutdown = 1;
                break;
3785 3786 3787
            case QEMU_OPTION_show_cursor:
                cursor_hide = 0;
                break;
3788
            case QEMU_OPTION_uuid:
3789
                if (qemu_uuid_parse(optarg, &qemu_uuid) < 0) {
3790
                    error_report("failed to parse UUID string: wrong format");
3791 3792
                    exit(1);
                }
3793
                qemu_uuid_set = true;
3794
                break;
3795 3796
            case QEMU_OPTION_option_rom:
                if (nb_option_roms >= MAX_OPTION_ROMS) {
3797
                    error_report("too many option ROMs");
3798 3799
                    exit(1);
                }
3800 3801
                opts = qemu_opts_parse_noisily(qemu_find_opts("option-rom"),
                                               optarg, true);
3802 3803 3804
                if (!opts) {
                    exit(1);
                }
3805 3806 3807 3808
                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) {
3809
                    error_report("Option ROM file is not specified");
3810 3811
                    exit(1);
                }
3812 3813
                nb_option_roms++;
                break;
3814
            case QEMU_OPTION_semihosting:
3815 3816
                semihosting.enabled = true;
                semihosting.target = SEMIHOSTING_TARGET_AUTO;
3817 3818
                break;
            case QEMU_OPTION_semihosting_config:
3819
                semihosting.enabled = true;
3820 3821
                opts = qemu_opts_parse_noisily(qemu_find_opts("semihosting-config"),
                                               optarg, false);
3822
                if (opts != NULL) {
3823
                    semihosting.enabled = qemu_opt_get_bool(opts, "enable",
3824 3825 3826 3827
                                                            true);
                    const char *target = qemu_opt_get(opts, "target");
                    if (target != NULL) {
                        if (strcmp("native", target) == 0) {
3828
                            semihosting.target = SEMIHOSTING_TARGET_NATIVE;
3829
                        } else if (strcmp("gdb", target) == 0) {
3830
                            semihosting.target = SEMIHOSTING_TARGET_GDB;
3831
                        } else  if (strcmp("auto", target) == 0) {
3832
                            semihosting.target = SEMIHOSTING_TARGET_AUTO;
3833
                        } else {
3834
                            error_report("unsupported semihosting-config %s",
3835
                                         optarg);
3836 3837 3838
                            exit(1);
                        }
                    } else {
3839
                        semihosting.target = SEMIHOSTING_TARGET_AUTO;
3840
                    }
3841 3842 3843
                    /* Set semihosting argument count and vector */
                    qemu_opt_foreach(opts, add_semihosting_arg,
                                     &semihosting, NULL);
3844
                } else {
3845
                    error_report("unsupported semihosting-config %s", optarg);
3846 3847
                    exit(1);
                }
3848
                break;
3849
            case QEMU_OPTION_name:
3850 3851
                opts = qemu_opts_parse_noisily(qemu_find_opts("name"),
                                               optarg, true);
3852 3853 3854
                if (!opts) {
                    exit(1);
                }
3855
                break;
3856 3857
            case QEMU_OPTION_prom_env:
                if (nb_prom_envs >= MAX_PROM_ENVS) {
3858
                    error_report("too many prom variables");
3859 3860 3861 3862 3863
                    exit(1);
                }
                prom_envs[nb_prom_envs] = optarg;
                nb_prom_envs++;
                break;
3864 3865
            case QEMU_OPTION_old_param:
                old_param = 1;
3866
                break;
3867
            case QEMU_OPTION_clock:
3868 3869 3870
                /* Clock options no longer exist.  Keep this option for
                 * backward compatibility.
                 */
3871
                break;
B
bellard 已提交
3872
            case QEMU_OPTION_startdate:
3873
                warn_report("This option is deprecated, use '-rtc base=' instead.");
3874 3875 3876
                configure_rtc_date_offset(optarg, 1);
                break;
            case QEMU_OPTION_rtc:
3877 3878
                opts = qemu_opts_parse_noisily(qemu_find_opts("rtc"), optarg,
                                               false);
3879 3880
                if (!opts) {
                    exit(1);
B
bellard 已提交
3881
                }
3882
                configure_rtc(opts);
B
bellard 已提交
3883
                break;
3884
            case QEMU_OPTION_tb_size:
3885 3886 3887 3888
#ifndef CONFIG_TCG
                error_report("TCG is disabled");
                exit(1);
#endif
3889 3890 3891
                if (qemu_strtoul(optarg, NULL, 0, &tcg_tb_size) < 0) {
                    error_report("Invalid argument to -tb-size");
                    exit(1);
3892
                }
3893
                break;
P
pbrook 已提交
3894
            case QEMU_OPTION_icount:
3895 3896
                icount_opts = qemu_opts_parse_noisily(qemu_find_opts("icount"),
                                                      optarg, true);
3897 3898 3899
                if (!icount_opts) {
                    exit(1);
                }
P
pbrook 已提交
3900
                break;
3901
            case QEMU_OPTION_incoming:
3902 3903 3904
                if (!incoming) {
                    runstate_set(RUN_STATE_INMIGRATE);
                }
3905 3906
                incoming = optarg;
                break;
3907
            case QEMU_OPTION_only_migratable:
3908 3909 3910 3911 3912 3913
                /*
                 * TODO: we can remove this option one day, and we
                 * should all use:
                 *
                 * "-global migration.only-migratable=true"
                 */
3914
                qemu_global_option("migration.only-migratable=true");
3915
                break;
3916
            case QEMU_OPTION_nodefaults:
3917
                has_defaults = 0;
3918
                break;
3919
            case QEMU_OPTION_xen_domid:
3920
                if (!(xen_available())) {
3921
                    error_report("Option not supported for this target");
3922 3923
                    exit(1);
                }
3924 3925 3926
                xen_domid = atoi(optarg);
                break;
            case QEMU_OPTION_xen_create:
3927
                if (!(xen_available())) {
3928
                    error_report("Option not supported for this target");
3929 3930
                    exit(1);
                }
3931 3932 3933
                xen_mode = XEN_CREATE;
                break;
            case QEMU_OPTION_xen_attach:
3934
                if (!(xen_available())) {
3935
                    error_report("Option not supported for this target");
3936 3937
                    exit(1);
                }
3938 3939
                xen_mode = XEN_ATTACH;
                break;
3940 3941 3942 3943 3944 3945 3946
            case QEMU_OPTION_xen_domid_restrict:
                if (!(xen_available())) {
                    error_report("Option not supported for this target");
                    exit(1);
                }
                xen_domid_restrict = true;
                break;
3947
            case QEMU_OPTION_trace:
3948 3949
                g_free(trace_file);
                trace_file = trace_opt_parse(optarg);
3950
                break;
3951 3952
            case QEMU_OPTION_readconfig:
                {
3953 3954
                    int ret = qemu_read_config_file(optarg);
                    if (ret < 0) {
3955 3956
                        error_report("read config %s: %s", optarg,
                                     strerror(-ret));
3957 3958 3959 3960
                        exit(1);
                    }
                    break;
                }
G
Gerd Hoffmann 已提交
3961 3962 3963
            case QEMU_OPTION_spice:
                olist = qemu_find_opts("spice");
                if (!olist) {
3964
                    error_report("spice support is disabled");
G
Gerd Hoffmann 已提交
3965 3966
                    exit(1);
                }
3967
                opts = qemu_opts_parse_noisily(olist, optarg, false);
G
Gerd Hoffmann 已提交
3968 3969 3970
                if (!opts) {
                    exit(1);
                }
G
Gerd Hoffmann 已提交
3971
                display_remote++;
G
Gerd Hoffmann 已提交
3972
                break;
3973 3974 3975 3976 3977 3978 3979 3980
            case QEMU_OPTION_writeconfig:
                {
                    FILE *fp;
                    if (strcmp(optarg, "-") == 0) {
                        fp = stdout;
                    } else {
                        fp = fopen(optarg, "w");
                        if (fp == NULL) {
3981 3982
                            error_report("open %s: %s", optarg,
                                         strerror(errno));
3983 3984 3985 3986
                            exit(1);
                        }
                    }
                    qemu_config_write(fp);
3987 3988 3989
                    if (fp != stdout) {
                        fclose(fp);
                    }
3990 3991
                    break;
                }
3992 3993 3994 3995 3996 3997
            case QEMU_OPTION_qtest:
                qtest_chrdev = optarg;
                break;
            case QEMU_OPTION_qtest_log:
                qtest_log = optarg;
                break;
3998
            case QEMU_OPTION_sandbox:
3999 4000
                opts = qemu_opts_parse_noisily(qemu_find_opts("sandbox"),
                                               optarg, true);
4001
                if (!opts) {
4002
                    exit(1);
4003 4004
                }
                break;
4005 4006
            case QEMU_OPTION_add_fd:
#ifndef _WIN32
4007 4008
                opts = qemu_opts_parse_noisily(qemu_find_opts("add-fd"),
                                               optarg, false);
4009
                if (!opts) {
4010
                    exit(1);
4011 4012 4013 4014 4015 4016 4017
                }
#else
                error_report("File descriptor passing is disabled on this "
                             "platform");
                exit(1);
#endif
                break;
4018
            case QEMU_OPTION_object:
4019 4020
                opts = qemu_opts_parse_noisily(qemu_find_opts("object"),
                                               optarg, true);
4021 4022 4023
                if (!opts) {
                    exit(1);
                }
4024
                break;
4025
            case QEMU_OPTION_realtime:
4026 4027
                opts = qemu_opts_parse_noisily(qemu_find_opts("realtime"),
                                               optarg, false);
4028 4029 4030
                if (!opts) {
                    exit(1);
                }
4031
                enable_mlock = qemu_opt_get_bool(opts, "mlock", true);
4032
                break;
4033
            case QEMU_OPTION_msg:
4034 4035
                opts = qemu_opts_parse_noisily(qemu_find_opts("msg"), optarg,
                                               false);
4036 4037 4038 4039 4040
                if (!opts) {
                    exit(1);
                }
                configure_msg(opts);
                break;
4041
            case QEMU_OPTION_dump_vmstate:
4042
                if (vmstate_dump_file) {
4043 4044
                    error_report("only one '-dump-vmstate' "
                                 "option may be given");
4045 4046
                    exit(1);
                }
4047 4048
                vmstate_dump_file = fopen(optarg, "w");
                if (vmstate_dump_file == NULL) {
4049
                    error_report("open %s: %s", optarg, strerror(errno));
4050 4051 4052
                    exit(1);
                }
                break;
4053 4054
            default:
                os_parse_cmd_args(popt->index, optarg);
4055
            }
4056 4057
        }
    }
4058 4059 4060 4061 4062
    /*
     * Clear error location left behind by the loop.
     * Best done right after the loop.  Do not insert code here!
     */
    loc_set_none();
4063

4064 4065
    replay_configure(icount_opts);

4066
    machine_class = select_machine();
4067 4068

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

4070
    os_daemonize();
4071
    rcu_disable_atfork();
4072

4073 4074 4075 4076 4077
    if (pid_file && qemu_create_pidfile(pid_file) != 0) {
        error_report("could not acquire pid file: %s", strerror(errno));
        exit(1);
    }

4078
    if (qemu_init_main_loop(&main_loop_err)) {
4079
        error_report_err(main_loop_err);
4080 4081 4082
        exit(1);
    }

4083 4084
    if (qemu_opts_foreach(qemu_find_opts("sandbox"),
                          parse_sandbox, NULL, NULL)) {
4085 4086 4087
        exit(1);
    }

4088 4089
    if (qemu_opts_foreach(qemu_find_opts("name"),
                          parse_name, NULL, NULL)) {
4090 4091 4092
        exit(1);
    }

4093
#ifndef _WIN32
4094 4095
    if (qemu_opts_foreach(qemu_find_opts("add-fd"),
                          parse_add_fd, NULL, NULL)) {
4096 4097 4098
        exit(1);
    }

4099 4100
    if (qemu_opts_foreach(qemu_find_opts("add-fd"),
                          cleanup_add_fd, NULL, NULL)) {
4101 4102 4103 4104
        exit(1);
    }
#endif

4105 4106
    current_machine = MACHINE(object_new(object_class_get_name(
                          OBJECT_CLASS(machine_class))));
4107 4108 4109
    if (machine_help_func(qemu_get_machine_opts(), current_machine)) {
        exit(0);
    }
4110 4111
    object_property_add_child(object_get_root(), "machine",
                              OBJECT(current_machine), &error_abort);
4112 4113 4114 4115 4116 4117 4118 4119 4120 4121

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

4122
    cpu_exec_init_all();
4123

4124
    if (machine_class->hw_version) {
4125
        qemu_set_hw_version(machine_class->hw_version);
4126 4127
    }

4128
    if (cpu_model && is_help_option(cpu_model)) {
4129
        list_cpus(stdout, &fprintf, cpu_model);
4130 4131 4132
        exit(0);
    }

4133 4134 4135
    if (!trace_init_backends()) {
        exit(1);
    }
4136 4137
    trace_init_file(trace_file);

4138
    /* Open the logfile at this point and set the log mask if necessary.
4139
     */
4140
    if (log_file) {
4141
        qemu_set_log_filename(log_file, &error_fatal);
4142 4143
    }

4144
    if (log_mask) {
4145 4146 4147 4148 4149 4150 4151
        int mask;
        mask = qemu_str_to_log_mask(log_mask);
        if (!mask) {
            qemu_print_log_usage(stdout);
            exit(1);
        }
        qemu_set_log(mask);
4152 4153
    } else {
        qemu_set_log(0);
4154
    }
4155

4156 4157 4158 4159 4160
    /* 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]);
    }
4161
    g_strfreev(dirs);
4162 4163

    /* try to find datadir relative to the executable path */
4164 4165 4166
    dir = os_find_datadir();
    qemu_add_data_dir(dir);
    g_free(dir);
G
Gerd Hoffmann 已提交
4167

4168
    /* add the datadir specified when building */
G
Gerd Hoffmann 已提交
4169
    qemu_add_data_dir(CONFIG_QEMU_DATADIR);
P
Paul Brook 已提交
4170

4171 4172 4173 4174 4175 4176 4177 4178
    /* -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);
    }

4179 4180 4181 4182 4183 4184 4185 4186 4187
    /* 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;

4188
    smp_parse(qemu_opts_find(qemu_find_opts("smp-opts"), NULL));
4189

4190 4191 4192 4193 4194 4195 4196
    /* 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 已提交
4197
    if (max_cpus > machine_class->max_cpus) {
4198 4199
        error_report("Invalid SMP CPUs %d. The max CPUs "
                     "supported by machine '%s' is %d", max_cpus,
4200
                     machine_class->name, machine_class->max_cpus);
4201 4202 4203
        exit(1);
    }

4204 4205 4206 4207
    /*
     * Get the default machine options from the machine if it is not already
     * specified either by the configuration file or by the command line.
     */
4208
    if (machine_class->default_machine_opts) {
4209
        qemu_opts_set_defaults(qemu_find_opts("machine"),
4210
                               machine_class->default_machine_opts, 0);
4211 4212
    }

4213 4214 4215 4216
    qemu_opts_foreach(qemu_find_opts("device"),
                      default_driver_check, NULL, NULL);
    qemu_opts_foreach(qemu_find_opts("global"),
                      default_driver_check, NULL, NULL);
4217

4218 4219 4220
    if (!vga_model && !default_vga) {
        vga_interface_type = VGA_DEVICE;
    }
4221
    if (!has_defaults || machine_class->no_serial) {
4222 4223
        default_serial = 0;
    }
4224
    if (!has_defaults || machine_class->no_parallel) {
4225 4226
        default_parallel = 0;
    }
4227
    if (!has_defaults || !machine_class->use_virtcon) {
4228 4229
        default_virtcon = 0;
    }
4230
    if (!has_defaults || !machine_class->use_sclp) {
4231 4232
        default_sclp = 0;
    }
4233
    if (!has_defaults || machine_class->no_floppy) {
4234 4235
        default_floppy = 0;
    }
4236
    if (!has_defaults || machine_class->no_cdrom) {
4237 4238
        default_cdrom = 0;
    }
4239
    if (!has_defaults || machine_class->no_sdcard) {
4240 4241
        default_sdcard = 0;
    }
4242 4243 4244 4245 4246
    if (!has_defaults) {
        default_monitor = 0;
        default_net = 0;
        default_vga = 0;
    }
4247

4248 4249 4250 4251 4252 4253 4254 4255 4256 4257
    if (is_daemonized()) {
        /* 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.
         */
4258
        if (nographic
4259 4260
            && (default_parallel || default_serial
                || default_monitor || default_virtcon)) {
4261
            error_report("-nographic cannot be used with -daemonize");
4262 4263 4264
            exit(1);
        }
#ifdef CONFIG_CURSES
4265
        if (dpy.type == DISPLAY_TYPE_CURSES) {
4266
            error_report("curses display cannot be used with -daemonize");
4267 4268 4269 4270 4271
            exit(1);
        }
#endif
    }

4272
    if (nographic) {
4273 4274
        if (default_parallel)
            add_device_config(DEV_PARALLEL, "null");
G
Gerd Hoffmann 已提交
4275 4276
        if (default_serial && default_monitor) {
            add_device_config(DEV_SERIAL, "mon:stdio");
4277 4278
        } else if (default_virtcon && default_monitor) {
            add_device_config(DEV_VIRTCON, "mon:stdio");
4279 4280
        } else if (default_sclp && default_monitor) {
            add_device_config(DEV_SCLP, "mon:stdio");
G
Gerd Hoffmann 已提交
4281 4282 4283
        } else {
            if (default_serial)
                add_device_config(DEV_SERIAL, "stdio");
4284 4285
            if (default_virtcon)
                add_device_config(DEV_VIRTCON, "stdio");
4286 4287 4288
            if (default_sclp) {
                add_device_config(DEV_SCLP, "stdio");
            }
G
Gerd Hoffmann 已提交
4289
            if (default_monitor)
M
Max Reitz 已提交
4290
                monitor_parse("stdio", "readline", false);
G
Gerd Hoffmann 已提交
4291
        }
4292 4293 4294
    } else {
        if (default_serial)
            add_device_config(DEV_SERIAL, "vc:80Cx24C");
4295 4296
        if (default_parallel)
            add_device_config(DEV_PARALLEL, "vc:80Cx24C");
4297
        if (default_monitor)
M
Max Reitz 已提交
4298
            monitor_parse("vc:80Cx24C", "readline", false);
4299 4300
        if (default_virtcon)
            add_device_config(DEV_VIRTCON, "vc:80Cx24C");
4301 4302 4303
        if (default_sclp) {
            add_device_config(DEV_SCLP, "vc:80Cx24C");
        }
4304 4305
    }

G
Gerd Hoffmann 已提交
4306 4307 4308 4309 4310
#if defined(CONFIG_VNC)
    if (!QTAILQ_EMPTY(&(qemu_find_opts("vnc")->head))) {
        display_remote++;
    }
#endif
4311
    if (dpy.type == DISPLAY_TYPE_DEFAULT && !display_remote) {
4312 4313 4314 4315
        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);
4316
#endif
4317
        }
4318
    }
4319 4320
    if (dpy.type == DISPLAY_TYPE_DEFAULT) {
        dpy.type = DISPLAY_TYPE_NONE;
4321 4322
    }

4323
    if ((no_frame || alt_grab || ctrl_grab) && dpy.type != DISPLAY_TYPE_SDL) {
4324 4325
        error_report("-no-frame, -alt-grab and -ctrl-grab are only valid "
                     "for SDL, ignoring option");
4326
    }
4327
    if (dpy.has_window_close &&
4328
        (dpy.type != DISPLAY_TYPE_GTK && dpy.type != DISPLAY_TYPE_SDL)) {
4329 4330
        error_report("-no-quit is only valid for GTK and SDL, "
                     "ignoring option");
4331 4332
    }

4333
    qemu_display_early_init(&dpy);
M
Marc-André Lureau 已提交
4334 4335
    qemu_console_early_init();

4336
    if (dpy.has_gl && dpy.gl && display_opengl == 0) {
4337
#if defined(CONFIG_OPENGL)
4338
        error_report("OpenGL is not supported by the display");
4339
#else
4340
        error_report("OpenGL support is disabled");
4341 4342 4343
#endif
        exit(1);
    }
4344

4345
    page_size_init();
T
TeLeMan 已提交
4346 4347
    socket_init();

4348
    if (qemu_opts_foreach(qemu_find_opts("object"),
4349
                          user_creatable_add_opts_foreach,
4350
                          object_create_initial, NULL)) {
4351
        exit(1);
4352 4353
    }

4354 4355 4356 4357 4358
    if (qemu_opts_foreach(qemu_find_opts("chardev"),
                          chardev_init_func, NULL, NULL)) {
        exit(1);
    }

4359
#ifdef CONFIG_VIRTFS
4360 4361
    if (qemu_opts_foreach(qemu_find_opts("fsdev"),
                          fsdev_init_func, NULL, NULL)) {
4362 4363 4364
        exit(1);
    }
#endif
4365

4366 4367
    if (qemu_opts_foreach(qemu_find_opts("device"),
                          device_help_func, NULL, NULL)) {
4368 4369 4370
        exit(0);
    }

4371
    machine_opts = qemu_get_machine_opts();
4372 4373
    if (qemu_opt_foreach(machine_opts, machine_set_property, current_machine,
                         NULL)) {
4374 4375 4376 4377
        object_unref(OBJECT(current_machine));
        exit(1);
    }

4378
    configure_accelerator(current_machine);
M
Marcelo Tosatti 已提交
4379

4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391
    /*
     * 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();

4392
    if (qtest_chrdev) {
4393
        qtest_init(qtest_chrdev, qtest_log, &error_fatal);
4394 4395
    }

4396 4397 4398 4399
    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");
4400
    bios_name = qemu_opt_get(machine_opts, "firmware");
4401

4402 4403
    opts = qemu_opts_find(qemu_find_opts("boot-opts"), NULL);
    if (opts) {
4404 4405
        boot_order = qemu_opt_get(opts, "order");
        if (boot_order) {
4406
            validate_bootdevices(boot_order, &error_fatal);
4407 4408
        }

4409 4410
        boot_once = qemu_opt_get(opts, "once");
        if (boot_once) {
4411
            validate_bootdevices(boot_once, &error_fatal);
4412 4413 4414
        }

        boot_menu = qemu_opt_get_bool(opts, "menu", boot_menu);
4415
        boot_strict = qemu_opt_get_bool(opts, "strict", false);
4416 4417
    }

4418 4419 4420 4421
    if (!boot_order) {
        boot_order = machine_class->default_boot_order;
    }

4422 4423
    if (!kernel_cmdline) {
        kernel_cmdline = "";
4424
        current_machine->kernel_cmdline = (char *)kernel_cmdline;
4425 4426
    }

4427
    linux_boot = (kernel_filename != NULL);
4428

4429
    if (!linux_boot && *kernel_cmdline != '\0') {
4430
        error_report("-append only allowed with -kernel option");
4431 4432 4433 4434
        exit(1);
    }

    if (!linux_boot && initrd_filename != NULL) {
4435
        error_report("-initrd only allowed with -kernel option");
4436 4437 4438
        exit(1);
    }

4439 4440 4441 4442 4443
    if (semihosting_enabled() && !semihosting_get_argc() && kernel_filename) {
        /* fall back to the -kernel/-append */
        semihosting_arg_fallback(kernel_filename, kernel_cmdline);
    }

4444
    os_set_line_buffering();
4445

4446 4447 4448
    /* spice needs the timers to be initialized by this point */
    qemu_spice_init();

4449
    cpu_ticks_init();
4450
    if (icount_opts) {
4451 4452
        if (!tcg_enabled()) {
            error_report("-icount is not allowed with hardware virtualization");
4453 4454 4455 4456
            exit(1);
        }
        configure_icount(icount_opts, &error_abort);
        qemu_opts_del(icount_opts);
4457
    }
4458

4459 4460 4461
    if (tcg_enabled()) {
        qemu_tcg_configure(accel_opts, &error_fatal);
    }
4462

4463 4464 4465 4466 4467 4468 4469 4470
    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
    }

4471 4472
    colo_info_init();

4473 4474
    if (net_init_clients(&err) < 0) {
        error_report_err(err);
4475
        exit(1);
B
bellard 已提交
4476
    }
B
bellard 已提交
4477

4478
    if (qemu_opts_foreach(qemu_find_opts("object"),
4479
                          user_creatable_add_opts_foreach,
4480
                          object_create_delayed, NULL)) {
4481 4482 4483
        exit(1);
    }

4484 4485 4486 4487
    if (tpm_init() < 0) {
        exit(1);
    }

4488
    /* init the bluetooth world */
4489 4490
    if (foreach_device_config(DEV_BT, bt_parse))
        exit(1);
4491

4492 4493 4494
    if (!xen_enabled()) {
        /* On 32-bit hosts, QEMU is limited by virtual address space */
        if (ram_size > (2047 << 20) && HOST_LONG_BITS == 32) {
4495
            error_report("at most 2047 MB RAM can be simulated");
4496 4497 4498
            exit(1);
        }
    }
4499

L
lirans@il.ibm.com 已提交
4500
    blk_mig_init();
4501
    ram_mig_init();
L
lirans@il.ibm.com 已提交
4502

4503 4504 4505 4506 4507 4508 4509
    /* 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);
    }

4510
    /* open the virtual block devices */
4511 4512 4513 4514 4515 4516 4517 4518 4519 4520
    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);
    }
4521 4522 4523 4524
    if (snapshot || replay_mode != REPLAY_MODE_NONE) {
        qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot,
                          NULL, NULL);
    }
4525
    if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func,
4526
                          &machine_class->block_default_type, NULL)) {
4527
        exit(1);
4528
    }
4529

4530
    default_drive(default_cdrom, snapshot, machine_class->block_default_type, 2,
4531 4532 4533
                  CDROM_OPTS);
    default_drive(default_floppy, snapshot, IF_FLOPPY, 0, FD_OPTS);
    default_drive(default_sdcard, snapshot, IF_SD, 0, SD_OPTS);
4534

4535 4536
    if (qemu_opts_foreach(qemu_find_opts("mon"),
                          mon_init_func, NULL, NULL)) {
4537 4538 4539
        exit(1);
    }

4540 4541
    if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
        exit(1);
4542 4543
    if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
        exit(1);
4544 4545
    if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
        exit(1);
4546 4547 4548
    if (foreach_device_config(DEV_SCLP, sclp_parse) < 0) {
        exit(1);
    }
4549 4550
    if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
        exit(1);
4551

4552
    /* If no default VGA is requested, the default is "none".  */
4553
    if (default_vga) {
4554 4555
        if (machine_class->default_display) {
            vga_model = machine_class->default_display;
4556
        } else if (vga_interface_available(VGA_CIRRUS)) {
4557
            vga_model = "cirrus";
4558
        } else if (vga_interface_available(VGA_STD)) {
4559 4560
            vga_model = "std";
        }
B
Blue Swirl 已提交
4561
    }
4562 4563 4564
    if (vga_model) {
        select_vgahw(vga_model);
    }
B
Blue Swirl 已提交
4565

4566 4567 4568 4569 4570 4571
    if (watchdog) {
        i = select_watchdog(watchdog);
        if (i > 0)
            exit (i == 1 ? 1 : 0);
    }

P
Pavel Dovgalyuk 已提交
4572 4573 4574 4575
    /* 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);
4576 4577
    qdev_machine_init();

4578
    current_machine->ram_size = ram_size;
4579 4580
    current_machine->maxram_size = maxram_size;
    current_machine->ram_slots = ram_slots;
4581 4582 4583
    current_machine->boot_order = boot_order;
    current_machine->cpu_model = cpu_model;

4584 4585 4586 4587 4588 4589 4590 4591
    /* parse features once if machine provides default cpu_type */
    if (machine_class->default_cpu_type) {
        current_machine->cpu_type = machine_class->default_cpu_type;
        if (cpu_model) {
            current_machine->cpu_type =
                cpu_parse_cpu_model(machine_class->default_cpu_type, cpu_model);
        }
    }
4592
    parse_numa_opts(current_machine);
4593

4594
    machine_run_board_init(current_machine);
4595

4596 4597
    realtime_init();

4598
    soundhw_init();
4599

4600 4601 4602 4603
    if (hax_enabled()) {
        hax_sync_vcpus();
    }

4604 4605 4606 4607 4608
    if (qemu_opts_foreach(qemu_find_opts("fw_cfg"),
                          parse_fw_cfg, fw_cfg_find(), NULL) != 0) {
        exit(1);
    }

4609
    /* init USB devices */
4610
    if (machine_usb(current_machine)) {
4611 4612
        if (foreach_device_config(DEV_USB, usb_parse) < 0)
            exit(1);
4613 4614
    }

4615 4616 4617
    /* Check if IGD GFX passthrough. */
    igd_gfx_passthru();

4618
    /* init generic devices */
4619
    rom_set_order_override(FW_CFG_ORDER_OVERRIDE_DEVICE);
4620 4621
    if (qemu_opts_foreach(qemu_find_opts("device"),
                          device_init_func, NULL, NULL)) {
4622
        exit(1);
4623
    }
4624

4625 4626
    cpu_synchronize_all_post_init();

4627
    rom_reset_order_override();
4628

4629 4630 4631
    /* Did we create any drives that we failed to create a device for? */
    drive_check_orphaned();

4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643
    /* 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.
     */
    if (!default_net) {
        net_check_clients();
    }

4644

4645
    if (boot_once) {
4646
        qemu_boot_set(boot_once, &error_fatal);
4647 4648 4649
        qemu_register_reset(restore_boot_order, g_strdup(boot_order));
    }

4650
    /* init local displays */
4651 4652
    ds = init_displaystate();
    qemu_display_init(ds, &dpy);
4653

4654 4655 4656
    /* must be after terminal init, SDL library changes signal handlers */
    os_setup_signal_handling();

4657
    /* init remote displays */
4658
#ifdef CONFIG_VNC
4659 4660
    qemu_opts_foreach(qemu_find_opts("vnc"),
                      vnc_init_func, NULL, NULL);
4661
#endif
4662

4663 4664
    if (using_spice) {
        qemu_spice_display_init();
G
Gerd Hoffmann 已提交
4665
    }
4666

4667
    if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) {
4668
        exit(1);
4669 4670
    }

4671 4672
    qdev_machine_creation_done();

4673 4674 4675
    /* 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());
4676 4677
    qemu_run_machine_init_done_notifiers();

4678
    if (rom_check_and_register_reset() != 0) {
4679
        error_report("rom check and register reset failed");
4680 4681
        exit(1);
    }
4682

4683 4684
    replay_start();

P
Pavel Dovgalyuk 已提交
4685 4686 4687 4688
    /* 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);
4689
    qemu_system_reset(SHUTDOWN_CAUSE_NONE);
4690
    register_global_state();
4691 4692 4693
    if (replay_mode != REPLAY_MODE_NONE) {
        replay_vmstate_init();
    } else if (loadvm) {
4694
        Error *local_err = NULL;
4695
        if (load_snapshot(loadvm, &local_err) < 0) {
4696
            error_report_err(local_err);
4697 4698 4699
            autostart = 0;
        }
    }
4700

4701
    qdev_prop_check_globals();
4702 4703 4704 4705 4706
    if (vmstate_dump_file) {
        /* dump and exit */
        dump_vmstate_json_to_file(vmstate_dump_file);
        return 0;
    }
4707

G
Glauber Costa 已提交
4708
    if (incoming) {
4709 4710 4711
        Error *local_err = NULL;
        qemu_start_incoming_migration(incoming, &local_err);
        if (local_err) {
4712
            error_reportf_err(local_err, "-incoming %s: ", incoming);
4713
            exit(1);
4714
        }
4715
    } else if (autostart) {
4716
        vm_start();
4717
    }
4718

4719
    os_setup_post();
4720

4721
    main_loop();
4722 4723
    replay_disable_events();

4724 4725 4726 4727 4728 4729 4730
    /* The ordering of the following is delicate.  Stop vcpus to prevent new
     * I/O requests being queued by the guest.  Then stop IOThreads (this
     * includes a drain operation and completes all request processing).  At
     * this point emulated devices are still associated with their IOThreads
     * (if any) but no longer have any work to do.  Only then can we close
     * block devices safely because we know there is no more I/O coming.
     */
4731
    pause_all_vcpus();
4732
    iothread_stop_all();
4733
    bdrv_close_all();
4734

4735
    res_free();
4736

4737
    /* vhost-user must be cleaned up before chardevs.  */
4738
    tpm_cleanup();
4739
    net_cleanup();
4740
    audio_cleanup();
4741
    monitor_cleanup();
4742
    qemu_chr_cleanup();
4743
    user_creatable_cleanup();
4744
    migration_object_finalize();
4745
    /* TODO: unref root container, check all devices are ok */
4746

4747 4748
    return 0;
}
反馈
建议
客服 返回
顶部