vl.c 139.3 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
 */
P
Peter Maydell 已提交
24
#include "qemu/osdep.h"
25
#include "qemu-version.h"
26 27
#include "qemu/cutils.h"
#include "qemu/help_option.h"
F
Fam Zheng 已提交
28
#include "qemu/uuid.h"
B
blueswir1 已提交
29

30
#ifdef CONFIG_SECCOMP
31
#include "sysemu/seccomp.h"
32 33
#endif

34 35 36 37
#if defined(CONFIG_VDE)
#include <libvdeplug.h>
#endif

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

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

56

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

112
#include "disas/disas.h"
B
bellard 已提交
113

114

J
Jan Kiszka 已提交
115
#include "slirp/libslirp.h"
116

117
#include "trace-root.h"
118
#include "trace/control.h"
119
#include "qemu/queue.h"
120
#include "sysemu/arch_init.h"
121

G
Gerd Hoffmann 已提交
122
#include "ui/qemu-spice.h"
123
#include "qapi/string-input-visitor.h"
P
Paolo Bonzini 已提交
124
#include "qapi/opts-visitor.h"
125 126
#include "qom/object_interfaces.h"
#include "qapi-event.h"
127
#include "exec/semihost.h"
128
#include "crypto/init.h"
129
#include "sysemu/replay.h"
130
#include "qapi/qmp/qerror.h"
131
#include "sysemu/iothread.h"
G
Gerd Hoffmann 已提交
132

133
#define MAX_VIRTIO_CONSOLES 1
134
#define MAX_SCLP_CONSOLES 1
135

136 137
static const char *data_dir[16];
static int data_dir_idx;
138
const char *bios_name = NULL;
139
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
140
int request_opengl = -1;
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;
B
blueswir1 已提交
154 155
static int full_screen = 0;
static int no_frame = 0;
156
int no_quit = 0;
157
static bool grab_on_hover;
158 159 160 161
Chardev *serial_hds[MAX_SERIAL_PORTS];
Chardev *parallel_hds[MAX_PARALLEL_PORTS];
Chardev *virtcon_hds[MAX_VIRTIO_CONSOLES];
Chardev *sclp_hds[MAX_SCLP_CONSOLES];
162
int win2k_install_hack = 0;
163
int singlestep = 0;
B
bellard 已提交
164
int smp_cpus = 1;
A
Andrew Jones 已提交
165
int max_cpus = 1;
166 167
int smp_cores = 1;
int smp_threads = 1;
B
bellard 已提交
168
int acpi_enabled = 1;
169
int no_hpet = 0;
170
int fd_bootchk = 1;
B
Blue Swirl 已提交
171
static int no_reboot;
A
aurel32 已提交
172
int no_shutdown = 0;
173
int cursor_hide = 1;
174
int graphic_rotate = 0;
175
const char *watchdog;
176
QEMUOptionRom option_rom[MAX_OPTION_ROMS];
177
int nb_option_roms;
178
int old_param = 0;
179
const char *qemu_name;
180
int alt_grab = 0;
181
int ctrl_grab = 0;
182 183
unsigned int nb_prom_envs = 0;
const char *prom_envs[MAX_PROM_ENVS];
184
int boot_menu;
185
bool boot_strict;
186
uint8_t *boot_splash_filedata;
187
size_t boot_splash_filedata_size;
188
uint8_t qemu_extra_params_fw[2];
189
int only_migratable; /* turn it off unless user states otherwise */
190

191
int icount_align_option;
192

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

G
Gerd Hoffmann 已提交
199 200 201
static NotifierList exit_notifiers =
    NOTIFIER_LIST_INITIALIZER(exit_notifiers);

202 203 204
static NotifierList machine_init_done_notifiers =
    NOTIFIER_LIST_INITIALIZER(machine_init_done_notifiers);

205
bool xen_allowed;
206 207
uint32_t xen_domid;
enum xen_mode xen_mode = XEN_EMULATE;
208
bool xen_domid_restrict;
209

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

static struct {
    const char *driver;
    int *flag;
} default_list[] = {
226 227
    { .driver = "isa-serial",           .flag = &default_serial    },
    { .driver = "isa-parallel",         .flag = &default_parallel  },
228
    { .driver = "isa-fdc",              .flag = &default_floppy    },
229
    { .driver = "floppy",               .flag = &default_floppy    },
230 231
    { .driver = "ide-cd",               .flag = &default_cdrom     },
    { .driver = "ide-hd",               .flag = &default_cdrom     },
232
    { .driver = "ide-drive",            .flag = &default_cdrom     },
233
    { .driver = "scsi-cd",              .flag = &default_cdrom     },
234
    { .driver = "scsi-hd",              .flag = &default_cdrom     },
235 236
    { .driver = "virtio-serial-pci",    .flag = &default_virtcon   },
    { .driver = "virtio-serial",        .flag = &default_virtcon   },
237 238 239 240 241 242
    { .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       },
243
    { .driver = "virtio-vga",           .flag = &default_vga       },
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 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
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,
        },
        { /* 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 = {
299 300 301 302 303 304
        /*
         * no elements => accept any
         * sanity checking will happen later
         * when setting machine properties
         */
        { }
305 306 307
    },
};

308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
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 */ }
    },
};

328 329
static QemuOptsList qemu_boot_opts = {
    .name = "boot-opts",
330 331
    .implied_opt_name = "order",
    .merge_lists = true,
332 333 334 335 336 337 338 339 340 341
    .head = QTAILQ_HEAD_INITIALIZER(qemu_boot_opts.head),
    .desc = {
        {
            .name = "order",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "once",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "menu",
342
            .type = QEMU_OPT_BOOL,
343 344 345 346 347 348 349 350 351
        }, {
            .name = "splash",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "splash-time",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "reboot-timeout",
            .type = QEMU_OPT_STRING,
352 353
        }, {
            .name = "strict",
354
            .type = QEMU_OPT_BOOL,
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389
        },
        { /*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 = {
        { }
    },
};

390 391 392 393 394
static QemuOptsList qemu_tpmdev_opts = {
    .name = "tpmdev",
    .implied_opt_name = "type",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_tpmdev_opts.head),
    .desc = {
395
        /* options are defined in the TPM backends */
396 397 398 399
        { /* end of list */ }
    },
};

400 401 402 403 404 405 406 407 408 409 410 411
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 */ }
    },
};

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

424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
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",
440 441 442 443 444 445
        }, {
            .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.",
446 447 448 449 450
        },
        { /* End of list */ }
    },
};

451 452 453 454 455 456 457 458 459 460
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,
        },
461 462 463 464 465 466 467 468
        {
            .name = "slots",
            .type = QEMU_OPT_NUMBER,
        },
        {
            .name = "maxmem",
            .type = QEMU_OPT_SIZE,
        },
469 470 471 472
        { /* end of list */ }
    },
};

473 474 475 476 477 478 479 480 481
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,
482 483 484
        }, {
            .name = "align",
            .type = QEMU_OPT_BOOL,
485 486 487
        }, {
            .name = "sleep",
            .type = QEMU_OPT_BOOL,
488 489 490 491 492 493
        }, {
            .name = "rr",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "rrfile",
            .type = QEMU_OPT_STRING,
494 495 496
        }, {
            .name = "rrsnapshot",
            .type = QEMU_OPT_STRING,
497 498 499 500 501
        },
        { /* end of list */ }
    },
};

502 503 504 505 506 507 508 509 510 511 512
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,
513 514 515
        }, {
            .name = "arg",
            .type = QEMU_OPT_STRING,
516 517 518 519 520
        },
        { /* end of list */ }
    },
};

521 522 523 524 525 526 527 528 529 530 531 532 533 534
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",
535 536 537 538
        }, {
            .name = "string",
            .type = QEMU_OPT_STRING,
            .help = "Sets content of the blob to be inserted from a string",
539 540 541 542 543
        },
        { /* end of list */ }
    },
};

544 545 546 547 548 549 550
/**
 * Get machine options
 *
 * Returns: machine options (never null).
 */
QemuOpts *qemu_get_machine_opts(void)
{
551
    return qemu_find_opts_singleton("machine");
552 553
}

554 555 556 557 558
const char *qemu_get_vm_name(void)
{
    return qemu_name;
}

559 560
static void res_free(void)
{
561 562
    g_free(boot_splash_filedata);
    boot_splash_filedata = NULL;
563 564
}

565
static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp)
566 567 568 569 570 571 572 573 574 575 576 577 578 579
{
    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;
}

580 581 582
/***********************************************************/
/* QEMU state */

583
static RunState current_run_state = RUN_STATE_PRELAUNCH;
584

585 586
/* We use RUN_STATE__MAX but any invalid value will do */
static RunState vmstop_requested = RUN_STATE__MAX;
587 588
static QemuMutex vmstop_lock;

589 590 591 592 593 594 595
typedef struct {
    RunState from;
    RunState to;
} RunStateTransition;

static const RunStateTransition runstate_transitions_def[] = {
    /*     from      ->     to      */
596
    { RUN_STATE_DEBUG, RUN_STATE_RUNNING },
597
    { RUN_STATE_DEBUG, RUN_STATE_FINISH_MIGRATE },
598
    { RUN_STATE_DEBUG, RUN_STATE_PRELAUNCH },
599

600 601
    { RUN_STATE_INMIGRATE, RUN_STATE_INTERNAL_ERROR },
    { RUN_STATE_INMIGRATE, RUN_STATE_IO_ERROR },
602
    { RUN_STATE_INMIGRATE, RUN_STATE_PAUSED },
603 604 605 606 607
    { 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 },
608
    { RUN_STATE_INMIGRATE, RUN_STATE_FINISH_MIGRATE },
609 610
    { RUN_STATE_INMIGRATE, RUN_STATE_PRELAUNCH },
    { RUN_STATE_INMIGRATE, RUN_STATE_POSTMIGRATE },
611
    { RUN_STATE_INMIGRATE, RUN_STATE_COLO },
612

613
    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED },
614
    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE },
615
    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PRELAUNCH },
616

617
    { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING },
618
    { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE },
619
    { RUN_STATE_IO_ERROR, RUN_STATE_PRELAUNCH },
620

621
    { RUN_STATE_PAUSED, RUN_STATE_RUNNING },
622
    { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE },
623
    { RUN_STATE_PAUSED, RUN_STATE_PRELAUNCH },
624
    { RUN_STATE_PAUSED, RUN_STATE_COLO},
625

626
    { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING },
627
    { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE },
628
    { RUN_STATE_POSTMIGRATE, RUN_STATE_PRELAUNCH },
629

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

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

639
    { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING },
640
    { RUN_STATE_RESTORE_VM, RUN_STATE_PRELAUNCH },
641

642 643
    { RUN_STATE_COLO, RUN_STATE_RUNNING },

644 645 646 647 648 649 650 651 652
    { 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 },
653
    { RUN_STATE_RUNNING, RUN_STATE_GUEST_PANICKED },
654
    { RUN_STATE_RUNNING, RUN_STATE_COLO},
655

656
    { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING },
657

658
    { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
659
    { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE },
660
    { RUN_STATE_SHUTDOWN, RUN_STATE_PRELAUNCH },
661

662 663 664 665
    { 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 },
666
    { RUN_STATE_SUSPENDED, RUN_STATE_PRELAUNCH },
667
    { RUN_STATE_SUSPENDED, RUN_STATE_COLO},
668

669
    { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
670
    { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },
671
    { RUN_STATE_WATCHDOG, RUN_STATE_PRELAUNCH },
672
    { RUN_STATE_WATCHDOG, RUN_STATE_COLO},
673

674
    { RUN_STATE_GUEST_PANICKED, RUN_STATE_RUNNING },
675
    { RUN_STATE_GUEST_PANICKED, RUN_STATE_FINISH_MIGRATE },
676
    { RUN_STATE_GUEST_PANICKED, RUN_STATE_PRELAUNCH },
677

678
    { RUN_STATE__MAX, RUN_STATE__MAX },
679 680
};

681
static bool runstate_valid_transitions[RUN_STATE__MAX][RUN_STATE__MAX];
682

683 684 685 686 687
bool runstate_check(RunState state)
{
    return current_run_state == state;
}

688 689 690 691 692 693 694 695 696 697 698 699
bool runstate_store(char *str, size_t size)
{
    const char *state = RunState_lookup[current_run_state];
    size_t len = strlen(state) + 1;

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

B
Blue Swirl 已提交
700
static void runstate_init(void)
701 702 703 704
{
    const RunStateTransition *p;

    memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions));
705
    for (p = &runstate_transitions_def[0]; p->from != RUN_STATE__MAX; p++) {
706 707
        runstate_valid_transitions[p->from][p->to] = true;
    }
708 709

    qemu_mutex_init(&vmstop_lock);
710 711 712
}

/* This function will abort() on invalid state transitions */
713 714
void runstate_set(RunState new_state)
{
715
    assert(new_state < RUN_STATE__MAX);
716

717 718 719 720
    if (current_run_state == new_state) {
        return;
    }

721
    if (!runstate_valid_transitions[current_run_state][new_state]) {
722 723 724
        error_report("invalid runstate transition: '%s' -> '%s'",
                     RunState_lookup[current_run_state],
                     RunState_lookup[new_state]);
725 726
        abort();
    }
727
    trace_runstate_set(new_state);
728 729 730
    current_run_state = new_state;
}

731
int runstate_is_running(void)
732
{
733
    return runstate_check(RUN_STATE_RUNNING);
734 735
}

736 737 738
bool runstate_needs_reset(void)
{
    return runstate_check(RUN_STATE_INTERNAL_ERROR) ||
739
        runstate_check(RUN_STATE_SHUTDOWN);
740 741
}

742
StatusInfo *qmp_query_status(Error **errp)
743
{
744 745 746 747 748 749 750
    StatusInfo *info = g_malloc0(sizeof(*info));

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

    return info;
751 752
}

753
bool qemu_vmstop_requested(RunState *r)
754 755 756
{
    qemu_mutex_lock(&vmstop_lock);
    *r = vmstop_requested;
757
    vmstop_requested = RUN_STATE__MAX;
758
    qemu_mutex_unlock(&vmstop_lock);
759
    return *r < RUN_STATE__MAX;
760 761 762 763 764 765 766 767 768 769 770 771 772 773
}

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

774 775
/***********************************************************/
/* real time host monotonic timer */
776

777 778 779 780 781
static time_t qemu_time(void)
{
    return qemu_clock_get_ms(QEMU_CLOCK_HOST) / 1000;
}

782 783 784 785
/***********************************************************/
/* host time/date access */
void qemu_get_timedate(struct tm *tm, int offset)
{
786
    time_t ti = qemu_time();
787 788 789 790

    ti += offset;
    if (rtc_date_offset == -1) {
        if (rtc_utc)
791
            gmtime_r(&ti, tm);
792
        else
793
            localtime_r(&ti, tm);
794 795
    } else {
        ti -= rtc_date_offset;
796
        gmtime_r(&ti, tm);
797 798 799 800 801 802 803 804 805 806
    }
}

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

    if (rtc_date_offset == -1)
        if (rtc_utc)
            seconds = mktimegm(tm);
807 808 809 810 811
        else {
            struct tm tmp = *tm;
            tmp.tm_isdst = -1; /* use timezone to figure it out */
            seconds = mktime(&tmp);
	}
812 813 814
    else
        seconds = mktimegm(tm) + rtc_date_offset;

815
    return seconds - qemu_time();
816 817
}

818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848
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:
849 850 851
            error_report("invalid date format");
            error_printf("valid formats: "
                         "'2006-06-17T16:01:21' or '2006-06-17'\n");
852 853
            exit(1);
        }
854
        rtc_date_offset = qemu_time() - rtc_start_date;
855 856 857 858 859 860 861 862 863 864 865 866
    }
}

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")) {
867
            Error *blocker = NULL;
868
            rtc_utc = 0;
869 870 871
            error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED,
                      "-rtc base=localtime");
            replay_add_blocker(blocker);
872 873 874 875
        } else {
            configure_rtc_date_offset(value, 0);
        }
    }
J
Jan Kiszka 已提交
876 877 878
    value = qemu_opt_get(opts, "clock");
    if (value) {
        if (!strcmp(value, "host")) {
879
            rtc_clock = QEMU_CLOCK_HOST;
P
Paolo Bonzini 已提交
880
        } else if (!strcmp(value, "rt")) {
881
            rtc_clock = QEMU_CLOCK_REALTIME;
J
Jan Kiszka 已提交
882
        } else if (!strcmp(value, "vm")) {
883
            rtc_clock = QEMU_CLOCK_VIRTUAL;
J
Jan Kiszka 已提交
884
        } else {
885
            error_report("invalid option value '%s'", value);
J
Jan Kiszka 已提交
886 887 888
            exit(1);
        }
    }
889 890
    value = qemu_opt_get(opts, "driftfix");
    if (value) {
B
Blue Swirl 已提交
891
        if (!strcmp(value, "slew")) {
892 893 894 895
            static GlobalProperty slew_lost_ticks = {
                .driver   = "mc146818rtc",
                .property = "lost_tick_policy",
                .value    = "slew",
896 897
            };

898
            qdev_prop_register_global(&slew_lost_ticks);
B
Blue Swirl 已提交
899
        } else if (!strcmp(value, "none")) {
900
            /* discard is default */
901
        } else {
902
            error_report("invalid option value '%s'", value);
903 904 905 906 907
            exit(1);
        }
    }
}

908 909 910 911 912
/***********************************************************/
/* Bluetooth support */
static int nb_hcis;
static int cur_hci;
static struct HCIInfo *hci_table[MAX_NICS];
913

914 915 916 917 918 919 920 921
struct HCIInfo *qemu_next_hci(void)
{
    if (cur_hci == nb_hcis)
        return &null_hci;

    return hci_table[cur_hci++];
}

922 923 924
static int bt_hci_parse(const char *str)
{
    struct HCIInfo *hci;
925
    bdaddr_t bdaddr;
926 927

    if (nb_hcis >= MAX_NICS) {
928
        error_report("too many bluetooth HCIs (max %i)", MAX_NICS);
929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
        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)
954 955
        error_report("warning: adding a VHCI to an empty scatternet %i",
                     vlan_id);
956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972

    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) {
973
            error_report("unrecognised bluetooth vlan Id");
974 975 976 977 978 979 980
            return 0;
        }
    }

    vlan = qemu_find_bt_vlan(vlan_id);

    if (!vlan->slave)
981 982
        error_report("warning: adding a slave device to an empty scatternet %i",
                     vlan_id);
983 984 985 986

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

987
    error_report("unsupported bluetooth device '%s'", devname);
988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
    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) {
1010
                        error_report("bad scatternet '%s'", p);
1011 1012 1013
                        return 1;
                    }
                } else {
1014
                    error_report("bad parameter '%s'", endp + 1);
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
                    return 1;
                }
            } else
                vlan = 0;

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

1026
    error_report("bad bluetooth parameter '%s'", opt);
1027 1028 1029
    return 1;
}

1030
static int parse_sandbox(void *opaque, QemuOpts *opts, Error **errp)
1031 1032 1033 1034 1035
{
    /* FIXME: change this to true for 1.3 */
    if (qemu_opt_get_bool(opts, "enable", false)) {
#ifdef CONFIG_SECCOMP
        if (seccomp_start() < 0) {
1036 1037
            error_report("failed to install seccomp syscall filter "
                         "in the kernel");
1038 1039 1040
            return -1;
        }
#else
1041
        error_report("seccomp support is disabled");
1042 1043 1044 1045 1046 1047 1048
        return -1;
#endif
    }

    return 0;
}

1049
static int parse_name(void *opaque, QemuOpts *opts, Error **errp)
1050 1051 1052
{
    const char *proc_name;

1053 1054 1055
    if (qemu_opt_get(opts, "debug-threads")) {
        qemu_thread_naming(qemu_opt_get_bool(opts, "debug-threads", false));
    }
1056 1057 1058 1059 1060 1061
    qemu_name = qemu_opt_get(opts, "guest");

    proc_name = qemu_opt_get(opts, "process");
    if (proc_name) {
        os_set_proc_name(proc_name);
    }
1062 1063

    return 0;
1064 1065
}

1066 1067 1068 1069 1070
bool defaults_enabled(void)
{
    return has_defaults;
}

1071
#ifndef _WIN32
1072
static int parse_add_fd(void *opaque, QemuOpts *opts, Error **errp)
1073 1074 1075 1076
{
    int fd, dupfd, flags;
    int64_t fdset_id;
    const char *fd_opaque = NULL;
1077
    AddfdInfo *fdinfo;
1078 1079 1080 1081 1082 1083

    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) {
1084
        error_report("fd option is required and must be non-negative");
1085 1086 1087 1088
        return -1;
    }

    if (fd <= STDERR_FILENO) {
1089
        error_report("fd cannot be a standard I/O stream");
1090 1091 1092 1093 1094 1095 1096 1097 1098
        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)) {
1099
        error_report("fd is not valid or already in use");
1100 1101 1102 1103
        return -1;
    }

    if (fdset_id < 0) {
1104
        error_report("set option is required and must be non-negative");
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
        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) {
1117
        error_report("error duplicating fd: %s", strerror(errno));
1118 1119 1120 1121
        return -1;
    }

    /* add the duplicate fd, and optionally the opaque string, to the fd set */
1122 1123 1124
    fdinfo = monitor_fdset_add_fd(dupfd, true, fdset_id, !!fd_opaque, fd_opaque,
                                  &error_abort);
    g_free(fdinfo);
1125 1126 1127 1128

    return 0;
}

1129
static int cleanup_add_fd(void *opaque, QemuOpts *opts, Error **errp)
1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
{
    int fd;

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

    return 0;
}
#endif

1140 1141 1142
/***********************************************************/
/* QEMU Block devices */

1143 1144 1145 1146 1147 1148
#define HD_OPTS "media=disk"
#define CDROM_OPTS "media=cdrom"
#define FD_OPTS ""
#define PFLASH_OPTS ""
#define MTD_OPTS ""
#define SD_OPTS ""
1149

1150
static int drive_init_func(void *opaque, QemuOpts *opts, Error **errp)
1151
{
1152
    BlockInterfaceType *block_default_type = opaque;
1153

1154
    return drive_new(opts, *block_default_type) == NULL;
1155 1156
}

1157
static int drive_enable_snapshot(void *opaque, QemuOpts *opts, Error **errp)
1158
{
G
Gonglei 已提交
1159
    if (qemu_opt_get(opts, "snapshot") == NULL) {
1160
        qemu_opt_set(opts, "snapshot", "on", &error_abort);
1161 1162 1163 1164
    }
    return 0;
}

1165 1166
static void default_drive(int enable, int snapshot, BlockInterfaceType type,
                          int index, const char *optstr)
1167 1168
{
    QemuOpts *opts;
1169
    DriveInfo *dinfo;
1170 1171 1172 1173 1174 1175 1176

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

    opts = drive_add(type, index, NULL, optstr);
    if (snapshot) {
1177
        drive_enable_snapshot(NULL, opts, NULL);
1178
    }
1179 1180 1181

    dinfo = drive_new(opts, type);
    if (!dinfo) {
1182 1183
        exit(1);
    }
1184 1185
    dinfo->is_default = true;

1186 1187
}

1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
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)
1215
{
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
    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;
1226
            threads = threads > 0 ? threads : 1;
1227 1228 1229
            if (cpus == 0) {
                cpus = cores * threads * sockets;
            }
1230 1231 1232
        } else if (cores == 0) {
            threads = threads > 0 ? threads : 1;
            cores = cpus / (sockets * threads);
1233
            cores = cores > 0 ? cores : 1;
1234
        } else if (threads == 0) {
1235
            threads = cpus / (cores * sockets);
1236
            threads = threads > 0 ? threads : 1;
1237
        } else if (sockets * cores * threads < cpus) {
1238 1239 1240 1241
            error_report("cpu topology: "
                         "sockets (%u) * cores (%u) * threads (%u) < "
                         "smp_cpus (%u)",
                         sockets, cores, threads, cpus);
1242
            exit(1);
1243
        }
1244

1245
        max_cpus = qemu_opt_get_number(opts, "maxcpus", cpus);
A
Andrew Jones 已提交
1246 1247 1248 1249 1250 1251

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

1252
        if (sockets * cores * threads > max_cpus) {
1253 1254 1255 1256
            error_report("cpu topology: "
                         "sockets (%u) * cores (%u) * threads (%u) > "
                         "maxcpus (%u)",
                         sockets, cores, threads, max_cpus);
1257 1258
            exit(1);
        }
1259 1260

        smp_cpus = cpus;
A
Andrew Jones 已提交
1261 1262
        smp_cores = cores;
        smp_threads = threads;
1263 1264
    }

A
Andrew Jones 已提交
1265
    if (smp_cpus > 1) {
1266 1267 1268 1269
        Error *blocker = NULL;
        error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED, "smp");
        replay_add_blocker(blocker);
    }
1270 1271
}

1272
static void realtime_init(void)
1273 1274 1275
{
    if (enable_mlock) {
        if (os_mlock() < 0) {
1276
            error_report("locking memory failed");
1277 1278 1279 1280 1281
            exit(1);
        }
    }
}

1282 1283 1284 1285 1286 1287

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

1288 1289 1290 1291 1292 1293
/***********************************************************/
/* Semihosting */

typedef struct SemihostingConfig {
    bool enabled;
    SemihostingTarget target;
1294 1295 1296
    const char **argv;
    int argc;
    const char *cmdline; /* concatenated argv */
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
} SemihostingConfig;

static SemihostingConfig semihosting;

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

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

1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362
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, " ");
    }
}

1363 1364 1365 1366 1367 1368 1369
/* 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 已提交
1370 1371 1372
/***********************************************************/
/* USB devices */

1373
static int usb_device_add(const char *devname)
B
bellard 已提交
1374
{
1375
    USBDevice *dev = NULL;
1376 1377 1378
#ifndef CONFIG_LINUX
    const char *p;
#endif
B
bellard 已提交
1379

1380
    if (!machine_usb(current_machine)) {
B
bellard 已提交
1381
        return -1;
1382
    }
B
bellard 已提交
1383

1384 1385 1386 1387 1388
    /* drivers with .usbdevice_name entry in USBDeviceInfo */
    dev = usbdevice_create(devname);
    if (dev)
        goto done;

1389
    /* the other ones */
1390 1391
#ifndef CONFIG_LINUX
    /* only the linux version is qdev-ified, usb-bsd still needs this */
B
bellard 已提交
1392
    if (strstart(devname, "host:", &p)) {
1393
        dev = usb_host_device_open(usb_bus_find(-1), p);
B
bellard 已提交
1394
    }
1395
#endif
P
pbrook 已提交
1396 1397 1398
    if (!dev)
        return -1;

1399
done:
B
bellard 已提交
1400 1401 1402
    return 0;
}

1403 1404 1405 1406 1407
static int usb_device_del(const char *devname)
{
    int bus_num, addr;
    const char *p;

1408 1409 1410
    if (strstart(devname, "host:", &p)) {
        return -1;
    }
1411

1412
    if (!machine_usb(current_machine)) {
1413
        return -1;
1414
    }
1415 1416 1417 1418 1419 1420 1421

    p = strchr(devname, '.');
    if (!p)
        return -1;
    bus_num = strtoul(devname, NULL, 0);
    addr = strtoul(p + 1, NULL, 0);

1422
    return usb_device_delete_addr(bus_num, addr);
1423 1424
}

1425 1426
static int usb_parse(const char *cmdline)
{
1427
    int r;
1428
    r = usb_device_add(cmdline);
1429
    if (r < 0) {
1430
        error_report("could not add USB device '%s'", cmdline);
1431 1432
    }
    return r;
1433 1434
}

1435
void hmp_usb_add(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1436
{
1437
    const char *devname = qdict_get_str(qdict, "devname");
1438
    if (usb_device_add(devname) < 0) {
1439
        error_report("could not add USB device '%s'", devname);
1440
    }
B
bellard 已提交
1441 1442
}

1443
void hmp_usb_del(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1444
{
1445 1446
    const char *devname = qdict_get_str(qdict, "devname");
    if (usb_device_del(devname) < 0) {
1447
        error_report("could not delete USB device '%s'", devname);
1448
    }
B
bellard 已提交
1449 1450
}

1451 1452 1453
/***********************************************************/
/* machine registration */

1454
MachineState *current_machine;
1455

1456
static MachineClass *find_machine(const char *name)
1457
{
1458
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1459
    MachineClass *mc = NULL;
1460

1461
    for (el = machines; el; el = el->next) {
1462
        MachineClass *temp = el->data;
1463

1464
        if (!strcmp(temp->name, name)) {
1465
            mc = temp;
1466 1467
            break;
        }
1468 1469
        if (temp->alias &&
            !strcmp(temp->alias, name)) {
1470
            mc = temp;
1471 1472
            break;
        }
1473
    }
1474 1475

    g_slist_free(machines);
1476
    return mc;
1477 1478
}

1479
MachineClass *find_default_machine(void)
1480
{
1481
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1482
    MachineClass *mc = NULL;
1483

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

1487
        if (temp->is_default) {
1488
            mc = temp;
1489
            break;
1490 1491
        }
    }
1492 1493

    g_slist_free(machines);
1494
    return mc;
1495 1496
}

1497 1498
MachineInfoList *qmp_query_machines(Error **errp)
{
1499
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1500 1501
    MachineInfoList *mach_list = NULL;

1502 1503
    for (el = machines; el; el = el->next) {
        MachineClass *mc = el->data;
1504 1505 1506 1507
        MachineInfoList *entry;
        MachineInfo *info;

        info = g_malloc0(sizeof(*info));
1508
        if (mc->is_default) {
1509 1510 1511 1512
            info->has_is_default = true;
            info->is_default = true;
        }

1513
        if (mc->alias) {
1514
            info->has_alias = true;
1515
            info->alias = g_strdup(mc->alias);
1516 1517
        }

1518 1519
        info->name = g_strdup(mc->name);
        info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
1520
        info->hotpluggable_cpus = mc->has_hotpluggable_cpus;
1521 1522 1523 1524 1525 1526 1527

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

1528
    g_slist_free(machines);
1529 1530 1531
    return mach_list;
}

1532 1533 1534
static int machine_help_func(QemuOpts *opts, MachineState *machine)
{
    ObjectProperty *prop;
1535
    ObjectPropertyIterator iter;
1536 1537 1538 1539 1540

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

1541 1542
    object_property_iter_init(&iter, OBJECT(machine));
    while ((prop = object_property_iter_next(&iter))) {
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558
        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;
}

1559 1560 1561
/***********************************************************/
/* main execution loop */

1562 1563 1564
struct vm_change_state_entry {
    VMChangeStateHandler *cb;
    void *opaque;
1565
    QLIST_ENTRY (vm_change_state_entry) entries;
1566 1567
};

1568
static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
1569 1570 1571 1572 1573 1574

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

1575
    e = g_malloc0(sizeof (*e));
1576 1577 1578

    e->cb = cb;
    e->opaque = opaque;
1579
    QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
1580 1581 1582 1583 1584
    return e;
}

void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
{
1585
    QLIST_REMOVE (e, entries);
1586
    g_free (e);
1587 1588
}

1589
void vm_state_notify(int running, RunState state)
1590
{
1591
    VMChangeStateEntry *e, *next;
1592

1593
    trace_vm_state_notify(running, state);
1594

1595
    QLIST_FOREACH_SAFE(e, &vm_change_state_head, entries, next) {
1596
        e->cb(e->opaque, running, state);
1597 1598 1599
    }
}

1600 1601 1602
static ShutdownCause reset_requested;
static ShutdownCause shutdown_requested;
static int shutdown_signal;
1603
static pid_t shutdown_pid;
B
bellard 已提交
1604
static int powerdown_requested;
1605
static int debug_requested;
1606
static int suspend_requested;
L
Liu, Jinsong 已提交
1607
static WakeupReason wakeup_reason;
1608 1609
static NotifierList powerdown_notifiers =
    NOTIFIER_LIST_INITIALIZER(powerdown_notifiers);
1610 1611 1612 1613
static NotifierList suspend_notifiers =
    NOTIFIER_LIST_INITIALIZER(suspend_notifiers);
static NotifierList wakeup_notifiers =
    NOTIFIER_LIST_INITIALIZER(wakeup_notifiers);
L
Liu, Jinsong 已提交
1614
static uint32_t wakeup_reason_mask = ~(1 << QEMU_WAKEUP_REASON_NONE);
1615

1616
ShutdownCause qemu_shutdown_requested_get(void)
1617 1618 1619 1620
{
    return shutdown_requested;
}

1621
ShutdownCause qemu_reset_requested_get(void)
1622 1623 1624 1625
{
    return reset_requested;
}

B
Blue Swirl 已提交
1626
static int qemu_shutdown_requested(void)
A
aurel32 已提交
1627
{
1628
    return atomic_xchg(&shutdown_requested, SHUTDOWN_CAUSE_NONE);
A
aurel32 已提交
1629 1630
}

B
Blue Swirl 已提交
1631
static void qemu_kill_report(void)
1632
{
1633
    if (!qtest_driver() && shutdown_signal) {
1634 1635 1636 1637
        if (shutdown_pid == 0) {
            /* This happens for eg ^C at the terminal, so it's worth
             * avoiding printing an odd message in that case.
             */
1638
            error_report("terminating on signal %d", shutdown_signal);
1639
        } else {
1640 1641 1642 1643 1644 1645
            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);
1646
        }
1647
        shutdown_signal = 0;
1648 1649 1650
    }
}

1651
static ShutdownCause qemu_reset_requested(void)
A
aurel32 已提交
1652
{
1653 1654
    ShutdownCause r = reset_requested;

P
Pavel Dovgalyuk 已提交
1655
    if (r && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) {
1656
        reset_requested = SHUTDOWN_CAUSE_NONE;
P
Pavel Dovgalyuk 已提交
1657 1658
        return r;
    }
1659
    return SHUTDOWN_CAUSE_NONE;
A
aurel32 已提交
1660 1661
}

1662 1663 1664
static int qemu_suspend_requested(void)
{
    int r = suspend_requested;
P
Pavel Dovgalyuk 已提交
1665 1666 1667 1668 1669
    if (r && replay_checkpoint(CHECKPOINT_SUSPEND_REQUESTED)) {
        suspend_requested = 0;
        return r;
    }
    return false;
1670 1671
}

L
Liu, Jinsong 已提交
1672
static WakeupReason qemu_wakeup_requested(void)
1673
{
L
Liu, Jinsong 已提交
1674
    return wakeup_reason;
1675 1676
}

B
Blue Swirl 已提交
1677
static int qemu_powerdown_requested(void)
A
aurel32 已提交
1678 1679 1680 1681 1682 1683
{
    int r = powerdown_requested;
    powerdown_requested = 0;
    return r;
}

1684 1685 1686 1687 1688 1689 1690
static int qemu_debug_requested(void)
{
    int r = debug_requested;
    debug_requested = 0;
    return r;
}

1691 1692 1693 1694
/*
 * Reset the VM. Issue an event unless @reason is SHUTDOWN_CAUSE_NONE.
 */
void qemu_system_reset(ShutdownCause reason)
1695
{
1696 1697 1698 1699
    MachineClass *mc;

    mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;

1700 1701
    cpu_synchronize_all_states();

1702 1703
    if (mc && mc->reset) {
        mc->reset();
1704 1705 1706
    } else {
        qemu_devices_reset();
    }
1707 1708
    if (reason) {
        /* TODO update event based on reason */
W
Wenchao Xia 已提交
1709
        qapi_event_send_reset(&error_abort);
J
Jan Kiszka 已提交
1710
    }
1711
    cpu_synchronize_all_post_reset();
1712 1713
}

1714
void qemu_system_guest_panicked(GuestPanicInformation *info)
1715
{
1716 1717
    qemu_log_mask(LOG_GUEST_ERROR, "Guest crashed\n");

1718 1719 1720
    if (current_cpu) {
        current_cpu->crash_occurred = true;
    }
1721 1722
    qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE,
                                   !!info, info, &error_abort);
1723
    vm_stop(RUN_STATE_GUEST_PANICKED);
1724 1725
    if (!no_shutdown) {
        qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF,
1726
                                       !!info, info, &error_abort);
1727
        qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC);
1728
    }
1729 1730

    if (info) {
1731
        if (info->type == GUEST_PANIC_INFORMATION_TYPE_HYPER_V) {
1732 1733
            qemu_log_mask(LOG_GUEST_ERROR, "HV crash parameters: (%#"PRIx64
                          " %#"PRIx64" %#"PRIx64" %#"PRIx64" %#"PRIx64")\n",
1734 1735 1736 1737 1738
                          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);
1739
        }
1740 1741
        qapi_free_GuestPanicInformation(info);
    }
1742 1743
}

1744
void qemu_system_reset_request(ShutdownCause reason)
1745
{
B
bellard 已提交
1746
    if (no_reboot) {
1747
        shutdown_requested = reason;
B
bellard 已提交
1748
    } else {
1749
        reset_requested = reason;
B
bellard 已提交
1750
    }
1751
    cpu_stop_current();
1752
    qemu_notify_event();
1753 1754
}

1755 1756 1757 1758
static void qemu_system_suspend(void)
{
    pause_all_vcpus();
    notifier_list_notify(&suspend_notifiers, NULL);
1759
    runstate_set(RUN_STATE_SUSPENDED);
W
Wenchao Xia 已提交
1760
    qapi_event_send_suspend(&error_abort);
1761 1762 1763 1764
}

void qemu_system_suspend_request(void)
{
1765
    if (runstate_check(RUN_STATE_SUSPENDED)) {
1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
        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)
{
1780 1781
    trace_system_wakeup_request(reason);

1782
    if (!runstate_check(RUN_STATE_SUSPENDED)) {
1783 1784 1785 1786 1787
        return;
    }
    if (!(wakeup_reason_mask & (1 << reason))) {
        return;
    }
1788
    runstate_set(RUN_STATE_RUNNING);
L
Liu, Jinsong 已提交
1789
    wakeup_reason = reason;
1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806
    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);
}

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

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

1820
void qemu_system_shutdown_request(ShutdownCause reason)
1821
{
1822 1823 1824
    trace_qemu_system_shutdown_request(reason);
    replay_shutdown_request(reason);
    shutdown_requested = reason;
1825
    qemu_notify_event();
1826 1827
}

1828 1829
static void qemu_system_powerdown(void)
{
1830
    qapi_event_send_powerdown(&error_abort);
1831 1832 1833
    notifier_list_notify(&powerdown_notifiers, NULL);
}

B
bellard 已提交
1834 1835
void qemu_system_powerdown_request(void)
{
1836
    trace_qemu_system_powerdown_request();
B
bellard 已提交
1837
    powerdown_requested = 1;
1838 1839 1840
    qemu_notify_event();
}

1841 1842 1843 1844 1845
void qemu_register_powerdown_notifier(Notifier *notifier)
{
    notifier_list_add(&powerdown_notifiers, notifier);
}

1846 1847 1848
void qemu_system_debug_request(void)
{
    debug_requested = 1;
1849
    qemu_notify_event();
1850 1851
}

1852 1853 1854
static bool main_loop_should_exit(void)
{
    RunState r;
1855 1856
    ShutdownCause request;

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

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

P
pbrook 已提交
1917 1918
static void version(void)
{
1919
    printf("QEMU emulator version " QEMU_VERSION QEMU_PKGVERSION "\n"
1920
           QEMU_COPYRIGHT "\n");
P
pbrook 已提交
1921 1922
}

1923
static void help(int exitcode)
1924
{
1925 1926 1927 1928 1929
    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());

1930 1931
#define QEMU_OPTIONS_GENERATE_HELP
#include "qemu-options-wrapper.h"
1932 1933

    printf("\nDuring emulation, the following keys are useful:\n"
1934 1935 1936 1937
           "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"
1938 1939
           "When using -nographic, press 'ctrl-a h' to get some help.\n");

1940
    exit(exitcode);
1941 1942
}

1943 1944 1945 1946 1947 1948
#define HAS_ARG 0x0001

typedef struct QEMUOption {
    const char *name;
    int flags;
    int index;
1949
    uint32_t arch_mask;
1950 1951
} QEMUOption;

B
blueswir1 已提交
1952
static const QEMUOption qemu_options[] = {
1953
    { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
1954 1955
#define QEMU_OPTIONS_GENERATE_OPTIONS
#include "qemu-options-wrapper.h"
1956
    { NULL },
B
bellard 已提交
1957
};
B
Blue Swirl 已提交
1958

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

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

2011 2012 2013 2014 2015 2016 2017 2018 2019 2020
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]);
}

2021
static void select_vgahw(const char *p)
2022 2023
{
    const char *opts;
2024
    int t;
2025

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

2058 2059 2060 2061 2062 2063
typedef enum DisplayType {
    DT_DEFAULT,
    DT_CURSES,
    DT_SDL,
    DT_COCOA,
    DT_GTK,
2064
    DT_EGL,
2065 2066 2067
    DT_NONE,
} DisplayType;

2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085
static DisplayType select_display(const char *p)
{
    const char *opts;
    DisplayType display = DT_DEFAULT;

    if (strstart(p, "sdl", &opts)) {
#ifdef CONFIG_SDL
        display = DT_SDL;
        while (*opts) {
            const char *nextopt;

            if (strstart(opts, ",frame=", &nextopt)) {
                opts = nextopt;
                if (strstart(opts, "on", &nextopt)) {
                    no_frame = 0;
                } else if (strstart(opts, "off", &nextopt)) {
                    no_frame = 1;
                } else {
2086
                    goto invalid_sdl_args;
2087 2088 2089 2090 2091 2092 2093 2094
                }
            } 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 {
2095
                    goto invalid_sdl_args;
2096 2097 2098 2099 2100 2101 2102 2103
                }
            } 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 {
2104
                    goto invalid_sdl_args;
2105 2106 2107 2108 2109 2110 2111 2112
                }
            } else if (strstart(opts, ",window_close=", &nextopt)) {
                opts = nextopt;
                if (strstart(opts, "on", &nextopt)) {
                    no_quit = 0;
                } else if (strstart(opts, "off", &nextopt)) {
                    no_quit = 1;
                } else {
2113
                    goto invalid_sdl_args;
2114
                }
2115 2116 2117 2118 2119 2120 2121 2122 2123
            } else if (strstart(opts, ",gl=", &nextopt)) {
                opts = nextopt;
                if (strstart(opts, "on", &nextopt)) {
                    request_opengl = 1;
                } else if (strstart(opts, "off", &nextopt)) {
                    request_opengl = 0;
                } else {
                    goto invalid_sdl_args;
                }
2124
            } else {
2125
            invalid_sdl_args:
2126
                error_report("invalid SDL option string");
2127
                exit(1);
2128 2129 2130 2131
            }
            opts = nextopt;
        }
#else
2132
        error_report("SDL support is disabled");
2133 2134
        exit(1);
#endif
2135
    } else if (strstart(p, "vnc", &opts)) {
2136
        if (*opts == '=') {
2137
            vnc_parse(opts + 1, &error_fatal);
2138
        } else {
2139
            error_report("VNC requires a display argument vnc=<display>");
2140 2141
            exit(1);
        }
2142 2143 2144 2145 2146 2147 2148 2149 2150
    } else if (strstart(p, "egl-headless", &opts)) {
#ifdef CONFIG_OPENGL
        request_opengl = 1;
        display_opengl = 1;
        display = DT_EGL;
#else
        fprintf(stderr, "egl support is disabled\n");
        exit(1);
#endif
2151 2152 2153 2154
    } else if (strstart(p, "curses", &opts)) {
#ifdef CONFIG_CURSES
        display = DT_CURSES;
#else
2155
        error_report("curses support is disabled");
2156
        exit(1);
2157 2158 2159 2160
#endif
    } else if (strstart(p, "gtk", &opts)) {
#ifdef CONFIG_GTK
        display = DT_GTK;
2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172
        while (*opts) {
            const char *nextopt;

            if (strstart(opts, ",grab_on_hover=", &nextopt)) {
                opts = nextopt;
                if (strstart(opts, "on", &nextopt)) {
                    grab_on_hover = true;
                } else if (strstart(opts, "off", &nextopt)) {
                    grab_on_hover = false;
                } else {
                    goto invalid_gtk_args;
                }
2173 2174 2175 2176 2177 2178 2179 2180 2181
            } else if (strstart(opts, ",gl=", &nextopt)) {
                opts = nextopt;
                if (strstart(opts, "on", &nextopt)) {
                    request_opengl = 1;
                } else if (strstart(opts, "off", &nextopt)) {
                    request_opengl = 0;
                } else {
                    goto invalid_gtk_args;
                }
2182 2183
            } else {
            invalid_gtk_args:
2184
                error_report("invalid GTK option string");
2185 2186 2187 2188
                exit(1);
            }
            opts = nextopt;
        }
2189
#else
2190
        error_report("GTK support is disabled");
2191
        exit(1);
2192
#endif
J
Jes Sorensen 已提交
2193 2194
    } else if (strstart(p, "none", &opts)) {
        display = DT_NONE;
2195
    } else {
2196
        error_report("unknown display type");
2197 2198 2199 2200 2201 2202
        exit(1);
    }

    return display;
}

2203 2204
static int balloon_parse(const char *arg)
{
2205
    QemuOpts *opts;
2206

2207 2208 2209 2210 2211 2212 2213
    if (strcmp(arg, "none") == 0) {
        return 0;
    }

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

    return -1;
2228 2229
}

P
Paul Brook 已提交
2230 2231
char *qemu_find_file(int type, const char *name)
{
2232
    int i;
P
Paul Brook 已提交
2233 2234 2235
    const char *subdir;
    char *buf;

2236 2237
    /* Try the name as a straight path first */
    if (access(name, R_OK) == 0) {
2238
        trace_load_file(name, name);
2239
        return g_strdup(name);
P
Paul Brook 已提交
2240
    }
2241

P
Paul Brook 已提交
2242 2243 2244 2245 2246 2247 2248 2249 2250 2251
    switch (type) {
    case QEMU_FILE_TYPE_BIOS:
        subdir = "";
        break;
    case QEMU_FILE_TYPE_KEYMAP:
        subdir = "keymaps/";
        break;
    default:
        abort();
    }
2252 2253 2254 2255 2256 2257 2258

    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;
        }
2259
        g_free(buf);
P
Paul Brook 已提交
2260
    }
2261
    return NULL;
P
Paul Brook 已提交
2262 2263
}

2264 2265 2266 2267 2268
static inline bool nonempty_str(const char *str)
{
    return str && *str;
}

2269 2270 2271 2272
static int parse_fw_cfg(void *opaque, QemuOpts *opts, Error **errp)
{
    gchar *buf;
    size_t size;
2273
    const char *name, *file, *str;
2274
    FWCfgState *fw_cfg = (FWCfgState *) opaque;
2275

2276
    if (fw_cfg == NULL) {
2277 2278 2279 2280 2281
        error_report("fw_cfg device not available");
        return -1;
    }
    name = qemu_opt_get(opts, "name");
    file = qemu_opt_get(opts, "file");
2282 2283 2284 2285 2286 2287 2288 2289 2290
    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");
2291 2292 2293 2294 2295 2296 2297
        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) {
2298
        error_report("warning: externally provided fw_cfg item names "
2299
                     "should be prefixed with \"opt/\"");
2300
    }
2301 2302 2303 2304 2305 2306 2307 2308
    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;
        }
2309
    }
2310 2311 2312 2313
    /* 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);
2314 2315 2316
    return 0;
}

2317
static int device_help_func(void *opaque, QemuOpts *opts, Error **errp)
2318 2319 2320 2321
{
    return qdev_device_help(opts);
}

2322
static int device_init_func(void *opaque, QemuOpts *opts, Error **errp)
2323
{
2324
    Error *err = NULL;
2325 2326
    DeviceState *dev;

2327 2328 2329
    dev = qdev_device_add(opts, &err);
    if (!dev) {
        error_report_err(err);
2330
        return -1;
2331
    }
2332
    object_unref(OBJECT(dev));
2333 2334 2335
    return 0;
}

2336
static int chardev_init_func(void *opaque, QemuOpts *opts, Error **errp)
2337
{
2338
    Error *local_err = NULL;
2339

2340
    qemu_chr_new_from_opts(opts, &local_err);
2341
    if (local_err) {
2342
        error_report_err(local_err);
2343
        return -1;
2344
    }
2345 2346 2347
    return 0;
}

2348
#ifdef CONFIG_VIRTFS
2349
static int fsdev_init_func(void *opaque, QemuOpts *opts, Error **errp)
2350
{
2351
    return qemu_fsdev_add(opts);
2352 2353 2354
}
#endif

2355
static int mon_init_func(void *opaque, QemuOpts *opts, Error **errp)
2356
{
2357
    Chardev *chr;
2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370
    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 {
2371
        error_report("unknown monitor mode \"%s\"", mode);
2372 2373 2374
        exit(1);
    }

2375 2376 2377
    if (qemu_opt_get_bool(opts, "pretty", 0))
        flags |= MONITOR_USE_PRETTY;

2378 2379 2380
    if (qemu_opt_get_bool(opts, "default", 0)) {
        error_report("option 'default' does nothing and is deprecated");
    }
2381 2382 2383 2384

    chardev = qemu_opt_get(opts, "chardev");
    chr = qemu_chr_find(chardev);
    if (chr == NULL) {
2385
        error_report("chardev \"%s\" not found", chardev);
2386 2387 2388 2389 2390 2391 2392
        exit(1);
    }

    monitor_init(chr, flags);
    return 0;
}

M
Max Reitz 已提交
2393
static void monitor_parse(const char *optarg, const char *mode, bool pretty)
2394 2395 2396 2397 2398 2399 2400 2401 2402
{
    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 {
2403 2404
        snprintf(label, sizeof(label), "compat_monitor%d",
                 monitor_device_index);
2405 2406
        opts = qemu_chr_parse_compat(label, optarg);
        if (!opts) {
2407
            error_report("parse error: %s", optarg);
2408 2409 2410 2411
            exit(1);
        }
    }

2412
    opts = qemu_opts_create(qemu_find_opts("mon"), label, 1, &error_fatal);
2413 2414
    qemu_opt_set(opts, "mode", mode, &error_abort);
    qemu_opt_set(opts, "chardev", label, &error_abort);
2415
    qemu_opt_set_bool(opts, "pretty", pretty, &error_abort);
2416 2417 2418
    monitor_device_index++;
}

2419 2420
struct device_config {
    enum {
2421 2422 2423 2424 2425
        DEV_USB,       /* -usbdevice     */
        DEV_BT,        /* -bt            */
        DEV_SERIAL,    /* -serial        */
        DEV_PARALLEL,  /* -parallel      */
        DEV_VIRTCON,   /* -virtioconsole */
2426
        DEV_DEBUGCON,  /* -debugcon */
2427
        DEV_GDB,       /* -gdb, -s */
2428
        DEV_SCLP,      /* s390 sclp */
2429 2430
    } type;
    const char *cmdline;
2431
    Location loc;
2432
    QTAILQ_ENTRY(device_config) next;
2433
};
B
Blue Swirl 已提交
2434 2435 2436

static QTAILQ_HEAD(, device_config) device_configs =
    QTAILQ_HEAD_INITIALIZER(device_configs);
2437 2438 2439 2440 2441

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

2442
    conf = g_malloc0(sizeof(*conf));
2443 2444
    conf->type = type;
    conf->cmdline = cmdline;
2445
    loc_save(&conf->loc);
2446
    QTAILQ_INSERT_TAIL(&device_configs, conf, next);
2447 2448 2449 2450 2451 2452 2453
}

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

2454
    QTAILQ_FOREACH(conf, &device_configs, next) {
2455 2456
        if (conf->type != type)
            continue;
2457
        loc_push_restore(&conf->loc);
2458
        rc = func(conf->cmdline);
2459
        loc_pop(&conf->loc);
G
Gonglei 已提交
2460
        if (rc) {
2461
            return rc;
G
Gonglei 已提交
2462
        }
2463 2464 2465 2466
    }
    return 0;
}

2467 2468 2469 2470 2471 2472 2473 2474
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) {
2475
        error_report("too many serial ports");
2476 2477 2478
        exit(1);
    }
    snprintf(label, sizeof(label), "serial%d", index);
2479
    serial_hds[index] = qemu_chr_new(label, devname);
2480
    if (!serial_hds[index]) {
2481 2482
        error_report("could not connect serial device"
                     " to character backend '%s'", devname);
2483 2484 2485 2486 2487 2488
        return -1;
    }
    index++;
    return 0;
}

2489 2490 2491 2492 2493 2494 2495 2496
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) {
2497
        error_report("too many parallel ports");
2498 2499 2500
        exit(1);
    }
    snprintf(label, sizeof(label), "parallel%d", index);
2501
    parallel_hds[index] = qemu_chr_new(label, devname);
2502
    if (!parallel_hds[index]) {
2503 2504
        error_report("could not connect parallel device"
                     " to character backend '%s'", devname);
2505 2506 2507 2508 2509 2510
        return -1;
    }
    index++;
    return 0;
}

2511 2512
static int virtcon_parse(const char *devname)
{
2513
    QemuOptsList *device = qemu_find_opts("device");
2514 2515
    static int index = 0;
    char label[32];
2516
    QemuOpts *bus_opts, *dev_opts;
2517 2518 2519 2520

    if (strcmp(devname, "none") == 0)
        return 0;
    if (index == MAX_VIRTIO_CONSOLES) {
2521
        error_report("too many virtio consoles");
2522 2523
        exit(1);
    }
2524

2525
    bus_opts = qemu_opts_create(device, NULL, 0, &error_abort);
2526
    qemu_opt_set(bus_opts, "driver", "virtio-serial", &error_abort);
2527

2528
    dev_opts = qemu_opts_create(device, NULL, 0, &error_abort);
2529
    qemu_opt_set(dev_opts, "driver", "virtconsole", &error_abort);
2530

2531
    snprintf(label, sizeof(label), "virtcon%d", index);
2532
    virtcon_hds[index] = qemu_chr_new(label, devname);
2533
    if (!virtcon_hds[index]) {
2534 2535
        error_report("could not connect virtio console"
                     " to character backend '%s'", devname);
2536 2537
        return -1;
    }
2538
    qemu_opt_set(dev_opts, "chardev", label, &error_abort);
2539

2540 2541 2542 2543
    index++;
    return 0;
}

2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554
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) {
2555
        error_report("too many sclp consoles");
2556 2557 2558 2559 2560 2561
        exit(1);
    }

    assert(arch_type == QEMU_ARCH_S390X);

    dev_opts = qemu_opts_create(device, NULL, 0, NULL);
2562
    qemu_opt_set(dev_opts, "driver", "sclpconsole", &error_abort);
2563 2564

    snprintf(label, sizeof(label), "sclpcon%d", index);
2565
    sclp_hds[index] = qemu_chr_new(label, devname);
2566
    if (!sclp_hds[index]) {
2567 2568
        error_report("could not connect sclp console"
                     " to character backend '%s'", devname);
2569 2570
        return -1;
    }
2571
    qemu_opt_set(dev_opts, "chardev", label, &error_abort);
2572 2573 2574 2575 2576

    index++;
    return 0;
}

2577
static int debugcon_parse(const char *devname)
L
Laszlo Ersek 已提交
2578
{
2579 2580
    QemuOpts *opts;

2581
    if (!qemu_chr_new("debugcon", devname)) {
2582 2583
        exit(1);
    }
2584
    opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL);
2585
    if (!opts) {
2586
        error_report("already have a debugcon device");
2587 2588
        exit(1);
    }
2589 2590
    qemu_opt_set(opts, "driver", "isa-debugcon", &error_abort);
    qemu_opt_set(opts, "chardev", "debugcon", &error_abort);
2591 2592 2593
    return 0;
}

2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628
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)
2629
{
2630
    MachineClass *mc = NULL;
2631
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
2632 2633

    if (name) {
2634
        mc = find_machine(name);
2635
    }
2636
    if (mc) {
2637
        g_slist_free(machines);
2638
        return mc;
2639
    }
2640
    if (name && !is_help_option(name)) {
2641
        error_report("unsupported machine type");
2642
        error_printf("Use -machine help to list supported machines\n");
2643 2644
    } else {
        printf("Supported machines are:\n");
2645
        machines = g_slist_sort(machines, machine_class_cmp);
2646 2647
        for (el = machines; el; el = el->next) {
            MachineClass *mc = el->data;
2648 2649
            if (mc->alias) {
                printf("%-20s %s (alias of %s)\n", mc->alias, mc->desc, mc->name);
2650
            }
2651 2652
            printf("%-20s %s%s\n", mc->name, mc->desc,
                   mc->is_default ? " (default)" : "");
2653 2654
        }
    }
2655 2656

    g_slist_free(machines);
2657
    exit(!name || !is_help_option(name));
2658 2659
}

G
Gerd Hoffmann 已提交
2660 2661 2662 2663 2664 2665 2666
void qemu_add_exit_notifier(Notifier *notify)
{
    notifier_list_add(&exit_notifiers, notify);
}

void qemu_remove_exit_notifier(Notifier *notify)
{
P
Paolo Bonzini 已提交
2667
    notifier_remove(notify);
G
Gerd Hoffmann 已提交
2668 2669 2670 2671
}

static void qemu_run_exit_notifiers(void)
{
2672
    notifier_list_notify(&exit_notifiers, NULL);
G
Gerd Hoffmann 已提交
2673 2674
}

2675 2676
static bool machine_init_done;

2677 2678 2679
void qemu_add_machine_init_done_notifier(Notifier *notify)
{
    notifier_list_add(&machine_init_done_notifiers, notify);
2680 2681 2682
    if (machine_init_done) {
        notify->notify(notify, NULL);
    }
2683 2684
}

2685 2686 2687 2688 2689
void qemu_remove_machine_init_done_notifier(Notifier *notify)
{
    notifier_remove(notify);
}

2690 2691
static void qemu_run_machine_init_done_notifiers(void)
{
2692
    notifier_list_notify(&machine_init_done_notifiers, NULL);
2693
    machine_init_done = true;
2694 2695
}

2696 2697 2698 2699 2700 2701 2702 2703
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;

2704
    loc_set_cmdline(argv, optind, 1);
2705 2706 2707 2708 2709 2710 2711
    optind++;
    /* Treat --foo the same as -foo.  */
    if (r[1] == '-')
        r++;
    popt = qemu_options;
    for(;;) {
        if (!popt->name) {
2712
            error_report("invalid option");
2713 2714 2715 2716 2717 2718 2719 2720
            exit(1);
        }
        if (!strcmp(popt->name, r + 1))
            break;
        popt++;
    }
    if (popt->flags & HAS_ARG) {
        if (optind >= argc) {
2721
            error_report("requires an argument");
2722 2723 2724
            exit(1);
        }
        optarg = argv[optind++];
2725
        loc_set_cmdline(argv, optind - 2, 2);
2726 2727 2728 2729 2730 2731 2732 2733 2734 2735
    } else {
        optarg = NULL;
    }

    *poptarg = optarg;
    *poptind = optind;

    return popt;
}

2736
static MachineClass *select_machine(void)
2737
{
2738
    MachineClass *machine_class = find_default_machine();
2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749
    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) {
2750
        machine_class = machine_parse(optarg);
2751 2752
    }

2753
    if (!machine_class) {
2754 2755 2756 2757 2758 2759
        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);
2760
    return machine_class;
2761 2762
}

2763 2764 2765
static int machine_set_property(void *opaque,
                                const char *name, const char *value,
                                Error **errp)
2766 2767 2768
{
    Object *obj = OBJECT(opaque);
    Error *local_err = NULL;
2769
    char *p, *qom_name;
2770

2771
    if (strcmp(name, "type") == 0) {
2772 2773 2774
        return 0;
    }

2775
    qom_name = g_strdup(name);
2776 2777 2778
    for (p = qom_name; *p; p++) {
        if (*p == '_') {
            *p = '-';
2779 2780 2781
        }
    }

2782
    object_property_parse(obj, value, qom_name, &local_err);
2783
    g_free(qom_name);
2784 2785

    if (local_err) {
2786
        error_report_err(local_err);
2787 2788 2789 2790 2791 2792
        return -1;
    }

    return 0;
}

2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805

/*
 * 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)
{
    if (g_str_equal(type, "rng-egd")) {
        return false;
    }
2806

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

2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833
    /* 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;
    }

2834 2835 2836 2837 2838 2839
    return true;
}


/*
 * The remainder of object creation happens after the
2840
 * creation of chardev, fsdev, net clients and device data types.
2841 2842 2843 2844 2845 2846 2847
 */
static bool object_create_delayed(const char *type)
{
    return !object_create_initial(type);
}


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

    loc_push_none(&loc);
    qemu_opts_loc_restore(opts);
2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895

    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 */
2896
    qemu_opt_set_number(opts, "size", ram_size, &error_abort);
2897 2898 2899 2900 2901 2902 2903 2904
    *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);
2905
        slots = qemu_opt_get_number(opts, "slots", 0);
2906
        if (sz < ram_size) {
2907 2908 2909 2910
            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);
2911
            exit(EXIT_FAILURE);
2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922
        } 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);
2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933
            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);
    }
2934 2935

    loc_pop(&loc);
2936 2937
}

2938 2939 2940 2941 2942 2943 2944 2945 2946
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;
2947
    g->errp = &error_fatal;
2948 2949 2950 2951
    qdev_prop_register_global(g);
    return 0;
}

2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963
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;
}

M
malc 已提交
2964
int main(int argc, char **argv, char **envp)
2965
{
2966
    int i;
2967
    int snapshot, linux_boot;
2968
    const char *initrd_filename;
2969
    const char *kernel_filename, *kernel_cmdline;
2970 2971
    const char *boot_order = NULL;
    const char *boot_once = NULL;
2972
    DisplayState *ds;
2973
    int cyls, heads, secs, translation;
2974 2975
    QemuOpts *opts, *machine_opts;
    QemuOpts *hda_opts = NULL, *icount_opts = NULL, *accel_opts = NULL;
2976
    QemuOptsList *olist;
2977
    int optind;
2978
    const char *optarg;
2979
    const char *loadvm = NULL;
2980
    MachineClass *machine_class;
2981
    const char *cpu_model;
2982
    const char *vga_model = NULL;
2983 2984
    const char *qtest_chrdev = NULL;
    const char *qtest_log = NULL;
2985
    const char *pid_file = NULL;
2986
    const char *incoming = NULL;
2987
    bool defconfig = true;
2988
    bool userconfig = true;
2989
    bool nographic = false;
2990
    DisplayType display_type = DT_DEFAULT;
2991
    int display_remote = 0;
2992 2993
    const char *log_mask = NULL;
    const char *log_file = NULL;
2994
    char *trace_file = NULL;
2995
    ram_addr_t maxram_size;
2996
    uint64_t ram_slots = 0;
2997
    FILE *vmstate_dump_file = NULL;
2998
    Error *main_loop_err = NULL;
2999
    Error *err = NULL;
3000
    bool list_data_dirs = false;
3001 3002 3003 3004 3005 3006 3007
    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);
3008

3009 3010
    module_call_init(MODULE_INIT_TRACE);

3011
    qemu_init_cpu_list();
3012 3013 3014
    qemu_init_cpu_loop();
    qemu_mutex_lock_iothread();

G
Gerd Hoffmann 已提交
3015
    atexit(qemu_run_exit_notifiers);
3016
    error_set_progname(argv[0]);
3017
    qemu_init_exec_dir(argv[0]);
3018

3019
    module_call_init(MODULE_INIT_QOM);
3020
    monitor_init_qmp_commands();
3021

3022
    qemu_add_opts(&qemu_drive_opts);
3023 3024 3025
    qemu_add_drive_opts(&qemu_legacy_drive_opts);
    qemu_add_drive_opts(&qemu_common_drive_opts);
    qemu_add_drive_opts(&qemu_drive_opts);
3026
    qemu_add_drive_opts(&bdrv_runtime_opts);
3027 3028 3029 3030 3031 3032 3033 3034 3035 3036
    qemu_add_opts(&qemu_chardev_opts);
    qemu_add_opts(&qemu_device_opts);
    qemu_add_opts(&qemu_netdev_opts);
    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);
3037
    qemu_add_opts(&qemu_accel_opts);
3038
    qemu_add_opts(&qemu_mem_opts);
3039
    qemu_add_opts(&qemu_smp_opts);
3040 3041 3042 3043
    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);
3044
    qemu_add_opts(&qemu_tpmdev_opts);
3045
    qemu_add_opts(&qemu_realtime_opts);
3046
    qemu_add_opts(&qemu_msg_opts);
3047
    qemu_add_opts(&qemu_name_opts);
3048
    qemu_add_opts(&qemu_numa_opts);
3049
    qemu_add_opts(&qemu_icount_opts);
3050
    qemu_add_opts(&qemu_semihosting_config_opts);
3051
    qemu_add_opts(&qemu_fw_cfg_opts);
3052
    module_call_init(MODULE_INIT_OPTS);
3053

3054 3055
    runstate_init();

3056
    if (qcrypto_init(&err) < 0) {
3057
        error_reportf_err(err, "cannot initialize crypto: ");
3058 3059
        exit(1);
    }
3060
    rtc_clock = QEMU_CLOCK_HOST;
J
Jan Kiszka 已提交
3061

3062
    QLIST_INIT (&vm_change_state_head);
3063
    os_setup_early_signal_handling();
3064

3065
    cpu_model = NULL;
3066
    snapshot = 0;
3067 3068
    cyls = heads = secs = 0;
    translation = BIOS_ATA_TRANSLATION_AUTO;
3069

B
bellard 已提交
3070
    nb_nics = 0;
3071

3072 3073
    bdrv_init_with_whitelist();

3074
    autostart = 1;
3075

3076 3077 3078 3079 3080
    /* first pass of option parsing */
    optind = 1;
    while (optind < argc) {
        if (argv[optind][0] != '-') {
            /* disk image */
3081
            optind++;
3082 3083 3084 3085 3086 3087
        } else {
            const QEMUOption *popt;

            popt = lookup_opt(argc, argv, &optarg, &optind);
            switch (popt->index) {
            case QEMU_OPTION_nodefconfig:
3088
                defconfig = false;
3089
                break;
3090 3091 3092
            case QEMU_OPTION_nouserconfig:
                userconfig = false;
                break;
3093 3094 3095 3096
            }
        }
    }

3097 3098
    if (defconfig && userconfig) {
        if (qemu_read_default_config_file() < 0) {
3099
            exit(1);
3100 3101 3102 3103
        }
    }

    /* second pass of option parsing */
3104
    optind = 1;
3105
    for(;;) {
3106
        if (optind >= argc)
3107
            break;
3108
        if (argv[optind][0] != '-') {
3109
            hda_opts = drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
3110 3111 3112
        } else {
            const QEMUOption *popt;

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

3474 3475 3476 3477 3478
                    graphic_width = w;
                    graphic_height = h;
                    graphic_depth = depth;
                }
                break;
3479 3480 3481 3482 3483 3484 3485 3486
            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 已提交
3487
            case QEMU_OPTION_monitor:
3488
                default_monitor = 0;
3489
                if (strncmp(optarg, "none", 4)) {
M
Max Reitz 已提交
3490
                    monitor_parse(optarg, "readline", false);
3491
                }
3492 3493
                break;
            case QEMU_OPTION_qmp:
M
Max Reitz 已提交
3494 3495 3496 3497 3498
                monitor_parse(optarg, "control", false);
                default_monitor = 0;
                break;
            case QEMU_OPTION_qmp_pretty:
                monitor_parse(optarg, "control", true);
3499
                default_monitor = 0;
B
bellard 已提交
3500
                break;
G
Gerd Hoffmann 已提交
3501
            case QEMU_OPTION_mon:
3502 3503
                opts = qemu_opts_parse_noisily(qemu_find_opts("mon"), optarg,
                                               true);
G
Gerd Hoffmann 已提交
3504 3505 3506
                if (!opts) {
                    exit(1);
                }
3507
                default_monitor = 0;
G
Gerd Hoffmann 已提交
3508
                break;
3509
            case QEMU_OPTION_chardev:
3510 3511
                opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
                                               optarg, true);
3512 3513 3514 3515
                if (!opts) {
                    exit(1);
                }
                break;
3516
            case QEMU_OPTION_fsdev:
3517 3518
                olist = qemu_find_opts("fsdev");
                if (!olist) {
3519
                    error_report("fsdev support is disabled");
3520 3521
                    exit(1);
                }
3522
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3523 3524 3525 3526
                if (!opts) {
                    exit(1);
                }
                break;
3527
            case QEMU_OPTION_virtfs: {
3528 3529
                QemuOpts *fsdev;
                QemuOpts *device;
3530
                const char *writeout, *sock_fd, *socket;
3531

3532 3533
                olist = qemu_find_opts("virtfs");
                if (!olist) {
3534
                    error_report("virtfs support is disabled");
3535 3536
                    exit(1);
                }
3537
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3538 3539 3540 3541
                if (!opts) {
                    exit(1);
                }

3542
                if (qemu_opt_get(opts, "fsdriver") == NULL ||
3543
                    qemu_opt_get(opts, "mount_tag") == NULL) {
3544
                    error_report("Usage: -virtfs fsdriver,mount_tag=tag");
3545 3546
                    exit(1);
                }
3547
                fsdev = qemu_opts_create(qemu_find_opts("fsdev"),
3548
                                         qemu_opts_id(opts) ?:
3549 3550
                                         qemu_opt_get(opts, "mount_tag"),
                                         1, NULL);
3551
                if (!fsdev) {
3552
                    error_report("duplicate or invalid fsdev id: %s",
3553
                                 qemu_opt_get(opts, "mount_tag"));
3554 3555
                    exit(1);
                }
3556 3557 3558 3559

                writeout = qemu_opt_get(opts, "writeout");
                if (writeout) {
#ifdef CONFIG_SYNC_FILE_RANGE
3560
                    qemu_opt_set(fsdev, "writeout", writeout, &error_abort);
3561
#else
3562 3563
                    error_report("writeout=immediate not supported "
                                 "on this platform");
3564 3565 3566
                    exit(1);
#endif
                }
3567 3568 3569 3570
                qemu_opt_set(fsdev, "fsdriver",
                             qemu_opt_get(opts, "fsdriver"), &error_abort);
                qemu_opt_set(fsdev, "path", qemu_opt_get(opts, "path"),
                             &error_abort);
3571
                qemu_opt_set(fsdev, "security_model",
3572 3573
                             qemu_opt_get(opts, "security_model"),
                             &error_abort);
3574 3575
                socket = qemu_opt_get(opts, "socket");
                if (socket) {
3576
                    qemu_opt_set(fsdev, "socket", socket, &error_abort);
3577
                }
3578 3579
                sock_fd = qemu_opt_get(opts, "sock_fd");
                if (sock_fd) {
3580
                    qemu_opt_set(fsdev, "sock_fd", sock_fd, &error_abort);
3581
                }
3582

3583
                qemu_opt_set_bool(fsdev, "readonly",
3584 3585
                                  qemu_opt_get_bool(opts, "readonly", 0),
                                  &error_abort);
3586 3587
                device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                          &error_abort);
3588
                qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
3589
                qemu_opt_set(device, "fsdev",
3590
                             qemu_opts_id(fsdev), &error_abort);
3591
                qemu_opt_set(device, "mount_tag",
3592
                             qemu_opt_get(opts, "mount_tag"), &error_abort);
3593 3594
                break;
            }
3595 3596 3597 3598
            case QEMU_OPTION_virtfs_synth: {
                QemuOpts *fsdev;
                QemuOpts *device;

3599 3600
                fsdev = qemu_opts_create(qemu_find_opts("fsdev"), "v_synth",
                                         1, NULL);
3601
                if (!fsdev) {
3602
                    error_report("duplicate option: %s", "virtfs_synth");
3603 3604
                    exit(1);
                }
3605
                qemu_opt_set(fsdev, "fsdriver", "synth", &error_abort);
3606

3607 3608
                device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                          &error_abort);
3609 3610 3611
                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);
3612 3613
                break;
            }
B
bellard 已提交
3614
            case QEMU_OPTION_serial:
3615 3616
                add_device_config(DEV_SERIAL, optarg);
                default_serial = 0;
3617 3618 3619
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
B
bellard 已提交
3620
                break;
R
Richard W.M. Jones 已提交
3621
            case QEMU_OPTION_watchdog:
3622
                if (watchdog) {
3623
                    error_report("only one watchdog option may be given");
3624 3625 3626
                    return 1;
                }
                watchdog = optarg;
R
Richard W.M. Jones 已提交
3627 3628 3629
                break;
            case QEMU_OPTION_watchdog_action:
                if (select_watchdog_action(optarg) == -1) {
3630
                    error_report("unknown -watchdog-action parameter");
R
Richard W.M. Jones 已提交
3631 3632 3633
                    exit(1);
                }
                break;
3634
            case QEMU_OPTION_virtiocon:
3635 3636
                add_device_config(DEV_VIRTCON, optarg);
                default_virtcon = 0;
3637 3638 3639
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
3640
                break;
3641
            case QEMU_OPTION_parallel:
3642 3643
                add_device_config(DEV_PARALLEL, optarg);
                default_parallel = 0;
3644 3645 3646
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
3647
                break;
3648 3649 3650
            case QEMU_OPTION_debugcon:
                add_device_config(DEV_DEBUGCON, optarg);
                break;
3651 3652 3653
            case QEMU_OPTION_loadvm:
                loadvm = optarg;
                break;
3654 3655 3656
            case QEMU_OPTION_full_screen:
                full_screen = 1;
                break;
3657 3658 3659
            case QEMU_OPTION_no_frame:
                no_frame = 1;
                break;
3660 3661 3662
            case QEMU_OPTION_alt_grab:
                alt_grab = 1;
                break;
3663 3664 3665
            case QEMU_OPTION_ctrl_grab:
                ctrl_grab = 1;
                break;
3666 3667 3668
            case QEMU_OPTION_no_quit:
                no_quit = 1;
                break;
3669
            case QEMU_OPTION_sdl:
3670
#ifdef CONFIG_SDL
3671
                display_type = DT_SDL;
3672
                break;
3673
#else
3674
                error_report("SDL support is disabled");
3675
                exit(1);
3676
#endif
B
bellard 已提交
3677
            case QEMU_OPTION_pidfile:
3678
                pid_file = optarg;
B
bellard 已提交
3679
                break;
3680 3681 3682
            case QEMU_OPTION_win2k_hack:
                win2k_install_hack = 1;
                break;
3683
            case QEMU_OPTION_rtc_td_hack: {
3684 3685 3686 3687
                static GlobalProperty slew_lost_ticks = {
                    .driver   = "mc146818rtc",
                    .property = "lost_tick_policy",
                    .value    = "slew",
3688 3689
                };

3690
                qdev_prop_register_global(&slew_lost_ticks);
3691
                break;
3692
            }
3693
            case QEMU_OPTION_acpitable:
3694 3695
                opts = qemu_opts_parse_noisily(qemu_find_opts("acpi"),
                                               optarg, true);
3696 3697 3698
                if (!opts) {
                    exit(1);
                }
3699
                acpi_table_add(opts, &error_fatal);
3700
                break;
3701
            case QEMU_OPTION_smbios:
3702 3703
                opts = qemu_opts_parse_noisily(qemu_find_opts("smbios"),
                                               optarg, false);
3704 3705 3706
                if (!opts) {
                    exit(1);
                }
3707
                smbios_entry_add(opts, &error_fatal);
3708
                break;
3709
            case QEMU_OPTION_fwcfg:
3710 3711
                opts = qemu_opts_parse_noisily(qemu_find_opts("fw_cfg"),
                                               optarg, true);
3712 3713 3714 3715
                if (opts == NULL) {
                    exit(1);
                }
                break;
A
aliguori 已提交
3716
            case QEMU_OPTION_enable_kvm:
3717
                olist = qemu_find_opts("machine");
3718
                qemu_opts_parse_noisily(olist, "accel=kvm", false);
3719
                break;
3720 3721 3722 3723
            case QEMU_OPTION_enable_hax:
                olist = qemu_find_opts("machine");
                qemu_opts_parse_noisily(olist, "accel=hax", false);
                break;
3724
            case QEMU_OPTION_M:
3725 3726
            case QEMU_OPTION_machine:
                olist = qemu_find_opts("machine");
3727
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3728 3729 3730
                if (!opts) {
                    exit(1);
                }
A
aliguori 已提交
3731
                break;
3732 3733
             case QEMU_OPTION_no_kvm:
                olist = qemu_find_opts("machine");
3734
                qemu_opts_parse_noisily(olist, "accel=tcg", false);
3735
                break;
3736
            case QEMU_OPTION_no_kvm_pit: {
3737
                error_report("warning: ignoring deprecated option");
3738 3739
                break;
            }
3740
            case QEMU_OPTION_no_kvm_pit_reinjection: {
3741 3742 3743 3744
                static GlobalProperty kvm_pit_lost_tick_policy = {
                    .driver   = "kvm-pit",
                    .property = "lost_tick_policy",
                    .value    = "discard",
3745 3746
                };

3747 3748
                error_report("warning: deprecated, replaced by "
                             "-global kvm-pit.lost_tick_policy=discard");
3749
                qdev_prop_register_global(&kvm_pit_lost_tick_policy);
3750 3751
                break;
            }
3752 3753 3754
            case QEMU_OPTION_accel: {
                QemuOpts *accel_opts;

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

4080 4081
    replay_configure(icount_opts);

4082
    machine_class = select_machine();
4083 4084

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

4086 4087
    os_daemonize();

4088 4089 4090 4091 4092
    if (pid_file && qemu_create_pidfile(pid_file) != 0) {
        error_report("could not acquire pid file: %s", strerror(errno));
        exit(1);
    }

4093
    if (qemu_init_main_loop(&main_loop_err)) {
4094
        error_report_err(main_loop_err);
4095 4096 4097
        exit(1);
    }

4098 4099
    if (qemu_opts_foreach(qemu_find_opts("sandbox"),
                          parse_sandbox, NULL, NULL)) {
4100 4101 4102
        exit(1);
    }

4103 4104
    if (qemu_opts_foreach(qemu_find_opts("name"),
                          parse_name, NULL, NULL)) {
4105 4106 4107
        exit(1);
    }

4108
#ifndef _WIN32
4109 4110
    if (qemu_opts_foreach(qemu_find_opts("add-fd"),
                          parse_add_fd, NULL, NULL)) {
4111 4112 4113
        exit(1);
    }

4114 4115
    if (qemu_opts_foreach(qemu_find_opts("add-fd"),
                          cleanup_add_fd, NULL, NULL)) {
4116 4117 4118 4119
        exit(1);
    }
#endif

4120 4121
    current_machine = MACHINE(object_new(object_class_get_name(
                          OBJECT_CLASS(machine_class))));
4122 4123 4124
    if (machine_help_func(qemu_get_machine_opts(), current_machine)) {
        exit(0);
    }
4125 4126
    object_property_add_child(object_get_root(), "machine",
                              OBJECT(current_machine), &error_abort);
4127 4128 4129 4130 4131 4132 4133 4134 4135 4136

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

4137
    cpu_exec_init_all();
4138

4139
    if (machine_class->hw_version) {
4140
        qemu_set_hw_version(machine_class->hw_version);
4141 4142
    }

4143
    if (cpu_model && is_help_option(cpu_model)) {
4144
        list_cpus(stdout, &fprintf, cpu_model);
4145 4146 4147
        exit(0);
    }

4148 4149 4150
    if (!trace_init_backends()) {
        exit(1);
    }
4151 4152
    trace_init_file(trace_file);

4153
    /* Open the logfile at this point and set the log mask if necessary.
4154
     */
4155
    if (log_file) {
4156
        qemu_set_log_filename(log_file, &error_fatal);
4157 4158
    }

4159
    if (log_mask) {
4160 4161 4162 4163 4164 4165 4166
        int mask;
        mask = qemu_str_to_log_mask(log_mask);
        if (!mask) {
            qemu_print_log_usage(stdout);
            exit(1);
        }
        qemu_set_log(mask);
4167 4168
    } else {
        qemu_set_log(0);
4169
    }
4170

P
Paul Brook 已提交
4171 4172
    /* If no data_dir is specified then try to find it relative to the
       executable path.  */
4173
    if (data_dir_idx < ARRAY_SIZE(data_dir)) {
4174
        data_dir[data_dir_idx] = os_find_datadir();
4175 4176 4177
        if (data_dir[data_dir_idx] != NULL) {
            data_dir_idx++;
        }
P
Paul Brook 已提交
4178
    }
4179
    /* If all else fails use the install path specified when building. */
4180 4181
    if (data_dir_idx < ARRAY_SIZE(data_dir)) {
        data_dir[data_dir_idx++] = CONFIG_QEMU_DATADIR;
P
Paul Brook 已提交
4182 4183
    }

4184 4185 4186 4187 4188 4189 4190 4191
    /* -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);
    }

4192
    smp_parse(qemu_opts_find(qemu_find_opts("smp-opts"), NULL));
4193

4194
    machine_class->max_cpus = machine_class->max_cpus ?: 1; /* Default to UP */
A
Andrew Jones 已提交
4195
    if (max_cpus > machine_class->max_cpus) {
4196 4197 4198
        error_report("Number of SMP CPUs requested (%d) exceeds max CPUs "
                     "supported by machine '%s' (%d)", max_cpus,
                     machine_class->name, machine_class->max_cpus);
4199 4200 4201
        exit(1);
    }

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

4211 4212 4213 4214
    qemu_opts_foreach(qemu_find_opts("device"),
                      default_driver_check, NULL, NULL);
    qemu_opts_foreach(qemu_find_opts("global"),
                      default_driver_check, NULL, NULL);
4215

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

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

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

G
Gerd Hoffmann 已提交
4304 4305 4306 4307 4308
#if defined(CONFIG_VNC)
    if (!QTAILQ_EMPTY(&(qemu_find_opts("vnc")->head))) {
        display_remote++;
    }
#endif
4309 4310 4311
    if (display_type == DT_DEFAULT && !display_remote) {
#if defined(CONFIG_GTK)
        display_type = DT_GTK;
4312
#elif defined(CONFIG_SDL)
4313
        display_type = DT_SDL;
4314 4315
#elif defined(CONFIG_COCOA)
        display_type = DT_COCOA;
4316
#elif defined(CONFIG_VNC)
4317
        vnc_parse("localhost:0,to=99,id=default", &error_abort);
4318 4319 4320 4321 4322
#else
        display_type = DT_NONE;
#endif
    }

4323
    if ((no_frame || alt_grab || ctrl_grab) && display_type != DT_SDL) {
4324 4325
        error_report("-no-frame, -alt-grab and -ctrl-grab are only valid "
                     "for SDL, ignoring option");
4326 4327
    }
    if (no_quit && (display_type != DT_GTK && display_type != DT_SDL)) {
4328 4329
        error_report("-no-quit is only valid for GTK and SDL, "
                     "ignoring option");
4330 4331
    }

4332
    if (display_type == DT_GTK) {
4333
        early_gtk_display_init(request_opengl);
4334
    }
4335

4336 4337 4338
    if (display_type == DT_SDL) {
        sdl_display_early_init(request_opengl);
    }
4339

M
Marc-André Lureau 已提交
4340 4341
    qemu_console_early_init();

4342 4343
    if (request_opengl == 1 && display_opengl == 0) {
#if defined(CONFIG_OPENGL)
4344
        error_report("OpenGL is not supported by the display");
4345
#else
4346
        error_report("OpenGL support is disabled");
4347 4348 4349
#endif
        exit(1);
    }
4350

4351
    page_size_init();
T
TeLeMan 已提交
4352 4353
    socket_init();

4354
    if (qemu_opts_foreach(qemu_find_opts("object"),
4355
                          user_creatable_add_opts_foreach,
4356
                          object_create_initial, NULL)) {
4357
        exit(1);
4358 4359
    }

4360 4361 4362 4363 4364
    if (qemu_opts_foreach(qemu_find_opts("chardev"),
                          chardev_init_func, NULL, NULL)) {
        exit(1);
    }

4365
#ifdef CONFIG_VIRTFS
4366 4367
    if (qemu_opts_foreach(qemu_find_opts("fsdev"),
                          fsdev_init_func, NULL, NULL)) {
4368 4369 4370
        exit(1);
    }
#endif
4371

4372 4373
    if (qemu_opts_foreach(qemu_find_opts("device"),
                          device_help_func, NULL, NULL)) {
4374 4375 4376
        exit(0);
    }

4377
    machine_opts = qemu_get_machine_opts();
4378 4379
    if (qemu_opt_foreach(machine_opts, machine_set_property, current_machine,
                         NULL)) {
4380 4381 4382 4383
        object_unref(OBJECT(current_machine));
        exit(1);
    }

4384
    configure_accelerator(current_machine);
M
Marcelo Tosatti 已提交
4385

4386
    if (qtest_chrdev) {
4387
        qtest_init(qtest_chrdev, qtest_log, &error_fatal);
4388 4389
    }

4390 4391 4392 4393
    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");
4394
    bios_name = qemu_opt_get(machine_opts, "firmware");
4395

4396 4397
    opts = qemu_opts_find(qemu_find_opts("boot-opts"), NULL);
    if (opts) {
4398 4399
        boot_order = qemu_opt_get(opts, "order");
        if (boot_order) {
4400
            validate_bootdevices(boot_order, &error_fatal);
4401 4402
        }

4403 4404
        boot_once = qemu_opt_get(opts, "once");
        if (boot_once) {
4405
            validate_bootdevices(boot_once, &error_fatal);
4406 4407 4408
        }

        boot_menu = qemu_opt_get_bool(opts, "menu", boot_menu);
4409
        boot_strict = qemu_opt_get_bool(opts, "strict", false);
4410 4411
    }

4412 4413 4414 4415
    if (!boot_order) {
        boot_order = machine_class->default_boot_order;
    }

4416 4417
    if (!kernel_cmdline) {
        kernel_cmdline = "";
4418
        current_machine->kernel_cmdline = (char *)kernel_cmdline;
4419 4420
    }

4421
    linux_boot = (kernel_filename != NULL);
4422

4423
    if (!linux_boot && *kernel_cmdline != '\0') {
4424
        error_report("-append only allowed with -kernel option");
4425 4426 4427 4428
        exit(1);
    }

    if (!linux_boot && initrd_filename != NULL) {
4429
        error_report("-initrd only allowed with -kernel option");
4430 4431 4432
        exit(1);
    }

4433 4434 4435 4436 4437
    if (semihosting_enabled() && !semihosting_get_argc() && kernel_filename) {
        /* fall back to the -kernel/-append */
        semihosting_arg_fallback(kernel_filename, kernel_cmdline);
    }

4438
    os_set_line_buffering();
4439

4440 4441 4442
    /* spice needs the timers to be initialized by this point */
    qemu_spice_init();

4443
    cpu_ticks_init();
4444
    if (icount_opts) {
4445 4446
        if (!tcg_enabled()) {
            error_report("-icount is not allowed with hardware virtualization");
4447 4448 4449 4450
            exit(1);
        }
        configure_icount(icount_opts, &error_abort);
        qemu_opts_del(icount_opts);
4451
    }
4452

4453 4454
    qemu_tcg_configure(accel_opts, &error_fatal);

4455 4456 4457 4458 4459 4460 4461 4462
    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
    }

4463 4464
    colo_info_init();

4465 4466
    if (net_init_clients() < 0) {
        exit(1);
B
bellard 已提交
4467
    }
B
bellard 已提交
4468

4469
    if (qemu_opts_foreach(qemu_find_opts("object"),
4470
                          user_creatable_add_opts_foreach,
4471
                          object_create_delayed, NULL)) {
4472 4473 4474
        exit(1);
    }

4475 4476 4477 4478 4479 4480
#ifdef CONFIG_TPM
    if (tpm_init() < 0) {
        exit(1);
    }
#endif

4481
    /* init the bluetooth world */
4482 4483
    if (foreach_device_config(DEV_BT, bt_parse))
        exit(1);
4484

4485 4486 4487
    if (!xen_enabled()) {
        /* On 32-bit hosts, QEMU is limited by virtual address space */
        if (ram_size > (2047 << 20) && HOST_LONG_BITS == 32) {
4488
            error_report("at most 2047 MB RAM can be simulated");
4489 4490 4491
            exit(1);
        }
    }
4492

L
lirans@il.ibm.com 已提交
4493
    blk_mig_init();
4494
    ram_mig_init();
L
lirans@il.ibm.com 已提交
4495

4496 4497 4498 4499 4500 4501 4502
    /* 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);
    }

4503
    /* open the virtual block devices */
4504 4505 4506 4507 4508 4509 4510 4511 4512 4513
    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);
    }
4514 4515 4516 4517
    if (snapshot || replay_mode != REPLAY_MODE_NONE) {
        qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot,
                          NULL, NULL);
    }
4518
    if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func,
4519
                          &machine_class->block_default_type, NULL)) {
4520
        exit(1);
4521
    }
4522

4523
    default_drive(default_cdrom, snapshot, machine_class->block_default_type, 2,
4524 4525 4526
                  CDROM_OPTS);
    default_drive(default_floppy, snapshot, IF_FLOPPY, 0, FD_OPTS);
    default_drive(default_sdcard, snapshot, IF_SD, 0, SD_OPTS);
4527

4528
    parse_numa_opts(current_machine);
4529

4530 4531
    if (qemu_opts_foreach(qemu_find_opts("mon"),
                          mon_init_func, NULL, NULL)) {
4532 4533 4534
        exit(1);
    }

4535 4536
    if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
        exit(1);
4537 4538
    if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
        exit(1);
4539 4540
    if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
        exit(1);
4541 4542 4543
    if (foreach_device_config(DEV_SCLP, sclp_parse) < 0) {
        exit(1);
    }
4544 4545
    if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
        exit(1);
4546

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

4561 4562 4563 4564 4565 4566
    if (watchdog) {
        i = select_watchdog(watchdog);
        if (i > 0)
            exit (i == 1 ? 1 : 0);
    }

4567 4568
    machine_register_compat_props(current_machine);

4569 4570
    qemu_opts_foreach(qemu_find_opts("global"),
                      global_init_func, NULL, NULL);
4571

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
    machine_run_board_init(current_machine);
4585

4586 4587
    realtime_init();

4588 4589
    audio_init();

4590 4591 4592 4593
    if (hax_enabled()) {
        hax_sync_vcpus();
    }

4594 4595 4596 4597 4598
    if (qemu_opts_foreach(qemu_find_opts("fw_cfg"),
                          parse_fw_cfg, fw_cfg_find(), NULL) != 0) {
        exit(1);
    }

4599
    /* init USB devices */
4600
    if (machine_usb(current_machine)) {
4601 4602
        if (foreach_device_config(DEV_USB, usb_parse) < 0)
            exit(1);
4603 4604
    }

4605 4606 4607
    /* Check if IGD GFX passthrough. */
    igd_gfx_passthru();

4608
    /* init generic devices */
4609
    rom_set_order_override(FW_CFG_ORDER_OVERRIDE_DEVICE);
4610 4611
    if (qemu_opts_foreach(qemu_find_opts("device"),
                          device_init_func, NULL, NULL)) {
4612
        exit(1);
4613
    }
4614

4615 4616
    cpu_synchronize_all_post_init();

4617
    rom_reset_order_override();
4618

4619 4620 4621 4622 4623 4624 4625
    /*
     * Create frontends for -drive if=scsi leftovers.
     * Normally, frontends for -drive get created by machine
     * initialization for onboard SCSI HBAs.  However, we create a few
     * more ever since SCSI qdevification, but this is pretty much an
     * implementation accident, and deprecated.
     */
4626 4627
    scsi_legacy_handle_cmdline();

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

4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642
    /* 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();
    }

4643

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

4649
    ds = init_displaystate();
4650

4651
    /* init local displays */
4652 4653
    switch (display_type) {
    case DT_CURSES:
4654
        curses_display_init(ds, full_screen);
4655 4656 4657 4658
        break;
    case DT_SDL:
        sdl_display_init(ds, full_screen, no_frame);
        break;
4659
    case DT_COCOA:
4660 4661
        cocoa_display_init(ds, full_screen);
        break;
4662
    case DT_GTK:
4663
        gtk_display_init(ds, full_screen, grab_on_hover);
4664
        break;
4665 4666 4667 4668
    default:
        break;
    }

4669 4670 4671
    /* must be after terminal init, SDL library changes signal handlers */
    os_setup_signal_handling();

4672
    /* init remote displays */
4673
#ifdef CONFIG_VNC
4674 4675
    qemu_opts_foreach(qemu_find_opts("vnc"),
                      vnc_init_func, NULL, NULL);
4676
#endif
4677

4678 4679
    if (using_spice) {
        qemu_spice_display_init();
G
Gerd Hoffmann 已提交
4680
    }
4681

4682 4683 4684 4685 4686 4687
#ifdef CONFIG_OPENGL
    if (display_type == DT_EGL) {
        egl_headless_init();
    }
#endif

4688
    if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) {
4689
        exit(1);
4690 4691
    }

4692 4693
    qdev_machine_creation_done();

4694 4695 4696
    /* 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());
4697 4698
    qemu_run_machine_init_done_notifiers();

4699
    if (rom_check_and_register_reset() != 0) {
4700
        error_report("rom check and register reset failed");
4701 4702
        exit(1);
    }
4703

4704 4705
    replay_start();

P
Pavel Dovgalyuk 已提交
4706 4707 4708 4709
    /* 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);
4710
    qemu_system_reset(SHUTDOWN_CAUSE_NONE);
4711
    register_global_state();
4712 4713 4714
    if (replay_mode != REPLAY_MODE_NONE) {
        replay_vmstate_init();
    } else if (loadvm) {
4715 4716 4717
        Error *local_err = NULL;
        if (load_vmstate(loadvm, &local_err) < 0) {
            error_report_err(local_err);
4718 4719 4720
            autostart = 0;
        }
    }
4721

4722
    qdev_prop_check_globals();
4723 4724 4725 4726 4727
    if (vmstate_dump_file) {
        /* dump and exit */
        dump_vmstate_json_to_file(vmstate_dump_file);
        return 0;
    }
4728

G
Glauber Costa 已提交
4729
    if (incoming) {
4730 4731 4732
        Error *local_err = NULL;
        qemu_start_incoming_migration(incoming, &local_err);
        if (local_err) {
4733
            error_reportf_err(local_err, "-incoming %s: ", incoming);
4734
            exit(1);
4735
        }
4736
    } else if (autostart) {
4737
        vm_start();
4738
    }
4739

4740
    os_setup_post();
4741

4742
    main_loop();
4743
    replay_disable_events();
4744
    iothread_stop_all();
4745

4746 4747
    bdrv_close_all();
    pause_all_vcpus();
4748
    res_free();
4749

4750
    /* vhost-user must be cleaned up before chardevs.  */
4751
    net_cleanup();
4752
    audio_cleanup();
4753
    monitor_cleanup();
4754
    qemu_chr_cleanup();
4755
    /* TODO: unref root container, check all devices are ok */
4756

4757 4758
    return 0;
}
新手
引导
客服 返回
顶部