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

B
blueswir1 已提交
31 32
#include "config-host.h"

33
#ifdef CONFIG_SECCOMP
34
#include "sysemu/seccomp.h"
35 36
#endif

37 38 39 40
#if defined(CONFIG_VDE)
#include <libvdeplug.h>
#endif

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

54 55 56 57 58
#ifdef CONFIG_COCOA
#undef main
#define main qemu_main
#endif /* CONFIG_COCOA */

A
Anthony Liguori 已提交
59 60
#include <glib.h>

61
#include "qemu/error-report.h"
62
#include "qemu/sockets.h"
63 64
#include "hw/hw.h"
#include "hw/boards.h"
65
#include "sysemu/accel.h"
66
#include "hw/usb.h"
P
Paolo Bonzini 已提交
67 68
#include "hw/i386/pc.h"
#include "hw/isa/isa.h"
69
#include "hw/bt.h"
P
Paolo Bonzini 已提交
70
#include "sysemu/watchdog.h"
71
#include "hw/smbios/smbios.h"
P
Paolo Bonzini 已提交
72
#include "hw/xen/xen.h"
73
#include "hw/qdev.h"
74
#include "hw/loader.h"
75
#include "monitor/qdev.h"
76
#include "sysemu/bt.h"
P
Paolo Bonzini 已提交
77
#include "net/net.h"
78
#include "net/slirp.h"
79
#include "monitor/monitor.h"
80
#include "ui/console.h"
81
#include "sysemu/sysemu.h"
82
#include "sysemu/numa.h"
83
#include "exec/gdbstub.h"
84
#include "qemu/timer.h"
85
#include "sysemu/char.h"
M
Michael Tokarev 已提交
86
#include "qemu/bitmap.h"
87
#include "sysemu/blockdev.h"
P
Paolo Bonzini 已提交
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/kvm.h"
95
#include "qapi/qmp/qjson.h"
96 97
#include "qemu/option.h"
#include "qemu/config-file.h"
98
#include "qemu-options.h"
L
Luiz Capitulino 已提交
99
#include "qmp-commands.h"
100
#include "qemu/main-loop.h"
101
#ifdef CONFIG_VIRTFS
102 103
#include "fsdev/qemu-fsdev.h"
#endif
104
#include "sysemu/qtest.h"
105

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

108

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

111
#include "trace.h"
112
#include "trace/control.h"
113
#include "qemu/queue.h"
114 115
#include "sysemu/cpus.h"
#include "sysemu/arch_init.h"
116
#include "qemu/osdep.h"
B
Blue Swirl 已提交
117

G
Gerd Hoffmann 已提交
118
#include "ui/qemu-spice.h"
119
#include "qapi/string-input-visitor.h"
P
Paolo Bonzini 已提交
120
#include "qapi/opts-visitor.h"
W
Wenchao Xia 已提交
121 122
#include "qom/object_interfaces.h"
#include "qapi-event.h"
123
#include "exec/semihost.h"
124
#include "crypto/init.h"
P
Pavel Dovgalyuk 已提交
125
#include "sysemu/replay.h"
126
#include "qapi/qmp/qerror.h"
G
Gerd Hoffmann 已提交
127

128
#define MAX_VIRTIO_CONSOLES 1
129
#define MAX_SCLP_CONSOLES 1
130

131 132
static const char *data_dir[16];
static int data_dir_idx;
133
const char *bios_name = NULL;
M
malc 已提交
134
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
135
DisplayType display_type = DT_DEFAULT;
136
int request_opengl = -1;
G
Gerd Hoffmann 已提交
137
int display_opengl;
B
Blue Swirl 已提交
138
static int display_remote;
139
const char* keyboard_layout = NULL;
A
Anthony Liguori 已提交
140
ram_addr_t ram_size;
141 142
const char *mem_path = NULL;
int mem_prealloc = 0; /* force preallocation of physical target memory */
143
bool enable_mlock = false;
144
int nb_nics;
B
bellard 已提交
145
NICInfo nd_table[MAX_NICS];
P
Paolo Bonzini 已提交
146
int autostart;
147 148
static int rtc_utc = 1;
static int rtc_date_offset = -1; /* -1 means no change */
149
QEMUClockType rtc_clock;
G
Gerd Hoffmann 已提交
150
int vga_interface_type = VGA_NONE;
B
blueswir1 已提交
151 152
static int full_screen = 0;
static int no_frame = 0;
T
ths 已提交
153
int no_quit = 0;
154 155 156
#ifdef CONFIG_GTK
static bool grab_on_hover;
#endif
157
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
158
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
159
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
160
CharDriverState *sclp_hds[MAX_SCLP_CONSOLES];
161
int win2k_install_hack = 0;
162
int singlestep = 0;
B
bellard 已提交
163
int smp_cpus = 1;
164
int max_cpus = 0;
165 166
int smp_cores = 1;
int smp_threads = 1;
B
bellard 已提交
167
int acpi_enabled = 1;
A
aliguori 已提交
168
int no_hpet = 0;
B
bellard 已提交
169
int fd_bootchk = 1;
B
Blue Swirl 已提交
170
static int no_reboot;
A
aurel32 已提交
171
int no_shutdown = 0;
172
int cursor_hide = 1;
173
int graphic_rotate = 0;
M
Markus Armbruster 已提交
174
const char *watchdog;
G
Gleb Natapov 已提交
175
QEMUOptionRom option_rom[MAX_OPTION_ROMS];
176
int nb_option_roms;
177
int old_param = 0;
T
ths 已提交
178
const char *qemu_name;
T
ths 已提交
179
int alt_grab = 0;
180
int ctrl_grab = 0;
B
blueswir1 已提交
181 182
unsigned int nb_prom_envs = 0;
const char *prom_envs[MAX_PROM_ENVS];
183
int boot_menu;
184
bool boot_strict;
W
wayne 已提交
185
uint8_t *boot_splash_filedata;
186
size_t boot_splash_filedata_size;
W
wayne 已提交
187
uint8_t qemu_extra_params_fw[2];
188

189
int icount_align_option;
190

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

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

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

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

207
static int has_defaults = 1;
208
static int default_serial = 1;
G
Gerd Hoffmann 已提交
209
static int default_parallel = 1;
210
static int default_virtcon = 1;
211
static int default_sclp = 1;
G
Gerd Hoffmann 已提交
212
static int default_monitor = 1;
G
Gerd Hoffmann 已提交
213 214 215
static int default_floppy = 1;
static int default_cdrom = 1;
static int default_sdcard = 1;
216
static int default_vga = 1;
217 218 219 220 221

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

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 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 299 300 301 302 303 304 305 306 307 308 309
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_trace_opts = {
    .name = "trace",
    .implied_opt_name = "trace",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_trace_opts.head),
    .desc = {
        {
            .name = "events",
            .type = QEMU_OPT_STRING,
        },{
            .name = "file",
            .type = QEMU_OPT_STRING,
        },
        { /* end of list */ }
    },
};

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

static QemuOptsList qemu_machine_opts = {
    .name = "machine",
    .implied_opt_name = "type",
    .merge_lists = true,
    .head = QTAILQ_HEAD_INITIALIZER(qemu_machine_opts.head),
    .desc = {
310 311 312 313 314 315
        /*
         * no elements => accept any
         * sanity checking will happen later
         * when setting machine properties
         */
        { }
316 317 318 319 320
    },
};

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

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

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

S
Seiji Aguchi 已提交
403 404 405 406 407 408 409 410 411 412 413 414
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 */ }
    },
};

415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430
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",
431 432 433 434 435 436
        }, {
            .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.",
437 438 439 440 441
        },
        { /* End of list */ }
    },
};

I
Igor Mammedov 已提交
442 443 444 445 446 447 448 449 450 451
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,
        },
452 453 454 455 456 457 458 459
        {
            .name = "slots",
            .type = QEMU_OPT_NUMBER,
        },
        {
            .name = "maxmem",
            .type = QEMU_OPT_SIZE,
        },
I
Igor Mammedov 已提交
460 461 462 463
        { /* end of list */ }
    },
};

464 465 466 467 468 469 470 471 472
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,
473 474 475
        }, {
            .name = "align",
            .type = QEMU_OPT_BOOL,
476 477 478
        }, {
            .name = "sleep",
            .type = QEMU_OPT_BOOL,
P
Pavel Dovgalyuk 已提交
479 480 481 482 483 484
        }, {
            .name = "rr",
            .type = QEMU_OPT_STRING,
        }, {
            .name = "rrfile",
            .type = QEMU_OPT_STRING,
485 486 487 488 489
        },
        { /* end of list */ }
    },
};

490 491 492 493 494 495 496 497 498 499 500
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,
501 502 503
        }, {
            .name = "arg",
            .type = QEMU_OPT_STRING,
504 505 506 507 508
        },
        { /* end of list */ }
    },
};

509 510 511 512 513 514 515 516 517 518 519 520 521 522
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",
523 524 525 526
        }, {
            .name = "string",
            .type = QEMU_OPT_STRING,
            .help = "Sets content of the blob to be inserted from a string",
527 528 529 530 531
        },
        { /* end of list */ }
    },
};

532 533 534 535 536 537 538
/**
 * Get machine options
 *
 * Returns: machine options (never null).
 */
QemuOpts *qemu_get_machine_opts(void)
{
539
    return qemu_find_opts_singleton("machine");
540 541
}

542 543 544 545 546
const char *qemu_get_vm_name(void)
{
    return qemu_name;
}

W
wayne 已提交
547 548
static void res_free(void)
{
549 550
    g_free(boot_splash_filedata);
    boot_splash_filedata = NULL;
W
wayne 已提交
551 552
}

553
static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp)
554 555 556 557 558 559 560 561 562 563 564 565 566 567
{
    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;
}

568 569 570
/***********************************************************/
/* QEMU state */

571
static RunState current_run_state = RUN_STATE_PRELAUNCH;
572

573 574
/* We use RUN_STATE__MAX but any invalid value will do */
static RunState vmstop_requested = RUN_STATE__MAX;
575 576
static QemuMutex vmstop_lock;

577 578 579 580 581 582 583
typedef struct {
    RunState from;
    RunState to;
} RunStateTransition;

static const RunStateTransition runstate_transitions_def[] = {
    /*     from      ->     to      */
584
    { RUN_STATE_DEBUG, RUN_STATE_RUNNING },
585
    { RUN_STATE_DEBUG, RUN_STATE_FINISH_MIGRATE },
586

587 588
    { RUN_STATE_INMIGRATE, RUN_STATE_INTERNAL_ERROR },
    { RUN_STATE_INMIGRATE, RUN_STATE_IO_ERROR },
589
    { RUN_STATE_INMIGRATE, RUN_STATE_PAUSED },
590 591 592 593 594
    { 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 },
595
    { RUN_STATE_INMIGRATE, RUN_STATE_FINISH_MIGRATE },
596

597
    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED },
598
    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE },
599

600
    { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING },
601
    { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE },
602

603
    { RUN_STATE_PAUSED, RUN_STATE_RUNNING },
604
    { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE },
605

606
    { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING },
607
    { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE },
608

609
    { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING },
610
    { RUN_STATE_PRELAUNCH, RUN_STATE_FINISH_MIGRATE },
611
    { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE },
612

613 614
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING },
    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE },
615

616
    { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING },
617

618 619 620 621 622 623 624 625 626
    { 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 },
627
    { RUN_STATE_RUNNING, RUN_STATE_GUEST_PANICKED },
628

629
    { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING },
630

631
    { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
632
    { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE },
633

634 635 636 637 638
    { 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 },

639
    { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
640
    { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },
641

642
    { RUN_STATE_GUEST_PANICKED, RUN_STATE_RUNNING },
643
    { RUN_STATE_GUEST_PANICKED, RUN_STATE_FINISH_MIGRATE },
644

645
    { RUN_STATE__MAX, RUN_STATE__MAX },
646 647
};

648
static bool runstate_valid_transitions[RUN_STATE__MAX][RUN_STATE__MAX];
649

650 651 652 653 654
bool runstate_check(RunState state)
{
    return current_run_state == state;
}

J
Juan Quintela 已提交
655 656 657 658 659 660 661 662 663 664 665 666
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 已提交
667
static void runstate_init(void)
668 669 670 671
{
    const RunStateTransition *p;

    memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions));
672
    for (p = &runstate_transitions_def[0]; p->from != RUN_STATE__MAX; p++) {
673 674
        runstate_valid_transitions[p->from][p->to] = true;
    }
675 676

    qemu_mutex_init(&vmstop_lock);
677 678 679
}

/* This function will abort() on invalid state transitions */
680 681
void runstate_set(RunState new_state)
{
682
    assert(new_state < RUN_STATE__MAX);
683 684

    if (!runstate_valid_transitions[current_run_state][new_state]) {
685 686 687
        error_report("invalid runstate transition: '%s' -> '%s'",
                     RunState_lookup[current_run_state],
                     RunState_lookup[new_state]);
688 689
        abort();
    }
K
Kazuya Saito 已提交
690
    trace_runstate_set(new_state);
691 692 693
    current_run_state = new_state;
}

L
Luiz Capitulino 已提交
694
int runstate_is_running(void)
695
{
L
Luiz Capitulino 已提交
696
    return runstate_check(RUN_STATE_RUNNING);
697 698
}

699 700 701
bool runstate_needs_reset(void)
{
    return runstate_check(RUN_STATE_INTERNAL_ERROR) ||
702
        runstate_check(RUN_STATE_SHUTDOWN);
703 704
}

L
Luiz Capitulino 已提交
705
StatusInfo *qmp_query_status(Error **errp)
706
{
L
Luiz Capitulino 已提交
707 708 709 710 711 712 713
    StatusInfo *info = g_malloc0(sizeof(*info));

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

    return info;
714 715
}

716 717 718 719
static bool qemu_vmstop_requested(RunState *r)
{
    qemu_mutex_lock(&vmstop_lock);
    *r = vmstop_requested;
720
    vmstop_requested = RUN_STATE__MAX;
721
    qemu_mutex_unlock(&vmstop_lock);
722
    return *r < RUN_STATE__MAX;
723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
}

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

void vm_start(void)
{
    RunState requested;

    qemu_vmstop_requested(&requested);
742
    if (runstate_is_running() && requested == RUN_STATE__MAX) {
743 744 745 746 747 748 749 750 751
        return;
    }

    /* Ensure that a STOP/RESUME pair of events is emitted if a
     * vmstop request was pending.  The BLOCK_IO_ERROR event, for
     * example, according to documentation is always followed by
     * the STOP event.
     */
    if (runstate_is_running()) {
W
Wenchao Xia 已提交
752
        qapi_event_send_stop(&error_abort);
753 754 755 756 757 758 759
    } else {
        cpu_enable_ticks();
        runstate_set(RUN_STATE_RUNNING);
        vm_state_notify(1, RUN_STATE_RUNNING);
        resume_all_vcpus();
    }

W
Wenchao Xia 已提交
760
    qapi_event_send_resume(&error_abort);
761 762 763
}


764 765
/***********************************************************/
/* real time host monotonic timer */
766

767 768 769 770 771
static time_t qemu_time(void)
{
    return qemu_clock_get_ms(QEMU_CLOCK_HOST) / 1000;
}

772 773 774 775
/***********************************************************/
/* host time/date access */
void qemu_get_timedate(struct tm *tm, int offset)
{
776
    time_t ti = qemu_time();
777 778 779 780

    ti += offset;
    if (rtc_date_offset == -1) {
        if (rtc_utc)
781
            gmtime_r(&ti, tm);
782
        else
783
            localtime_r(&ti, tm);
784 785
    } else {
        ti -= rtc_date_offset;
786
        gmtime_r(&ti, tm);
787 788 789 790 791 792 793 794 795 796
    }
}

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

    if (rtc_date_offset == -1)
        if (rtc_utc)
            seconds = mktimegm(tm);
797 798 799 800 801
        else {
            struct tm tmp = *tm;
            tmp.tm_isdst = -1; /* use timezone to figure it out */
            seconds = mktime(&tmp);
	}
802 803 804
    else
        seconds = mktimegm(tm) + rtc_date_offset;

805
    return seconds - qemu_time();
806 807
}

J
Jan Kiszka 已提交
808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838
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:
839 840 841
            error_report("invalid date format");
            error_printf("valid formats: "
                         "'2006-06-17T16:01:21' or '2006-06-17'\n");
J
Jan Kiszka 已提交
842 843
            exit(1);
        }
844
        rtc_date_offset = qemu_time() - rtc_start_date;
J
Jan Kiszka 已提交
845 846 847 848 849 850 851 852 853 854 855 856
    }
}

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

            qdev_prop_register_global_list(slew_lost_ticks);
B
Blue Swirl 已提交
892
        } else if (!strcmp(value, "none")) {
893
            /* discard is default */
J
Jan Kiszka 已提交
894
        } else {
895
            error_report("invalid option value '%s'", value);
J
Jan Kiszka 已提交
896 897 898 899 900
            exit(1);
        }
    }
}

901 902 903 904 905
/***********************************************************/
/* Bluetooth support */
static int nb_hcis;
static int cur_hci;
static struct HCIInfo *hci_table[MAX_NICS];
906

907 908 909 910 911 912 913 914
struct HCIInfo *qemu_next_hci(void)
{
    if (cur_hci == nb_hcis)
        return &null_hci;

    return hci_table[cur_hci++];
}

915 916 917
static int bt_hci_parse(const char *str)
{
    struct HCIInfo *hci;
A
Anthony Liguori 已提交
918
    bdaddr_t bdaddr;
919 920

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

    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) {
966
            error_report("unrecognised bluetooth vlan Id");
967 968 969 970 971 972 973
            return 0;
        }
    }

    vlan = qemu_find_bt_vlan(vlan_id);

    if (!vlan->slave)
974 975
        error_report("warning: adding a slave device to an empty scatternet %i",
                     vlan_id);
976 977 978 979

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

E
Eduardo Habkost 已提交
980
    error_report("unsupported bluetooth device '%s'", devname);
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002
    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) {
1003
                        error_report("bad scatternet '%s'", p);
1004 1005 1006
                        return 1;
                    }
                } else {
1007
                    error_report("bad parameter '%s'", endp + 1);
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
                    return 1;
                }
            } else
                vlan = 0;

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

1019
    error_report("bad bluetooth parameter '%s'", opt);
1020 1021 1022
    return 1;
}

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

    return 0;
}

1042
static int parse_name(void *opaque, QemuOpts *opts, Error **errp)
1043 1044 1045
{
    const char *proc_name;

1046 1047 1048
    if (qemu_opt_get(opts, "debug-threads")) {
        qemu_thread_naming(qemu_opt_get_bool(opts, "debug-threads", false));
    }
1049 1050 1051 1052 1053 1054
    qemu_name = qemu_opt_get(opts, "guest");

    proc_name = qemu_opt_get(opts, "process");
    if (proc_name) {
        os_set_proc_name(proc_name);
    }
1055 1056

    return 0;
1057 1058
}

1059 1060 1061 1062 1063
bool defaults_enabled(void)
{
    return has_defaults;
}

1064
bool usb_enabled(void)
1065
{
1066
    return machine_usb(current_machine);
1067 1068
}

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

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

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

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

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

    return 0;
}

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

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

    return 0;
}
#endif

1138 1139 1140
/***********************************************************/
/* QEMU Block devices */

1141 1142 1143 1144 1145 1146
#define HD_OPTS "media=disk"
#define CDROM_OPTS "media=cdrom"
#define FD_OPTS ""
#define PFLASH_OPTS ""
#define MTD_OPTS ""
#define SD_OPTS ""
T
ths 已提交
1147

1148
static int drive_init_func(void *opaque, QemuOpts *opts, Error **errp)
G
Gerd Hoffmann 已提交
1149
{
1150
    BlockInterfaceType *block_default_type = opaque;
G
Gerd Hoffmann 已提交
1151

1152
    return drive_new(opts, *block_default_type) == NULL;
G
Gerd Hoffmann 已提交
1153 1154
}

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

1163 1164
static void default_drive(int enable, int snapshot, BlockInterfaceType type,
                          int index, const char *optstr)
1165 1166
{
    QemuOpts *opts;
J
John Snow 已提交
1167
    DriveInfo *dinfo;
1168 1169 1170 1171 1172 1173 1174

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

    opts = drive_add(type, index, NULL, optstr);
    if (snapshot) {
1175
        drive_enable_snapshot(NULL, opts, NULL);
1176
    }
J
John Snow 已提交
1177 1178 1179

    dinfo = drive_new(opts, type);
    if (!dinfo) {
1180 1181
        exit(1);
    }
J
John Snow 已提交
1182 1183
    dinfo->is_default = true;

1184 1185
}

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
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)
1213
{
1214
    if (opts) {
1215

1216 1217 1218 1219 1220 1221 1222 1223 1224
        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;
1225
            threads = threads > 0 ? threads : 1;
1226 1227 1228
            if (cpus == 0) {
                cpus = cores * threads * sockets;
            }
1229 1230 1231
        } else if (cores == 0) {
            threads = threads > 0 ? threads : 1;
            cores = cpus / (sockets * threads);
1232
        } else if (threads == 0) {
1233
            threads = cpus / (cores * sockets);
1234
        } else if (sockets * cores * threads < cpus) {
1235 1236 1237 1238
            error_report("cpu topology: "
                         "sockets (%u) * cores (%u) * threads (%u) < "
                         "smp_cpus (%u)",
                         sockets, cores, threads, cpus);
1239
            exit(1);
1240
        }
1241

1242 1243
        max_cpus = qemu_opt_get_number(opts, "maxcpus", cpus);
        if (sockets * cores * threads > max_cpus) {
1244 1245 1246 1247
            error_report("cpu topology: "
                         "sockets (%u) * cores (%u) * threads (%u) > "
                         "maxcpus (%u)",
                         sockets, cores, threads, max_cpus);
1248 1249
            exit(1);
        }
1250 1251 1252 1253 1254

        smp_cpus = cpus;
        smp_cores = cores > 0 ? cores : 1;
        smp_threads = threads > 0 ? threads : 1;

1255
    }
1256 1257

    if (max_cpus == 0) {
1258
        max_cpus = smp_cpus;
1259 1260
    }

1261
    if (max_cpus > MAX_CPUMASK_BITS) {
1262
        error_report("unsupported number of maxcpus");
1263 1264 1265
        exit(1);
    }
    if (max_cpus < smp_cpus) {
1266
        error_report("maxcpus must be equal to or greater than smp");
1267 1268 1269
        exit(1);
    }

1270 1271 1272 1273 1274
    if (smp_cpus > 1 || smp_cores > 1 || smp_threads > 1) {
        Error *blocker = NULL;
        error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED, "smp");
        replay_add_blocker(blocker);
    }
1275 1276
}

1277
static void realtime_init(void)
1278 1279 1280
{
    if (enable_mlock) {
        if (os_mlock() < 0) {
1281
            error_report("locking memory failed");
1282 1283 1284 1285 1286
            exit(1);
        }
    }
}

S
Seiji Aguchi 已提交
1287 1288 1289 1290 1291 1292

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

1293 1294 1295 1296 1297 1298
/***********************************************************/
/* Semihosting */

typedef struct SemihostingConfig {
    bool enabled;
    SemihostingTarget target;
1299 1300 1301
    const char **argv;
    int argc;
    const char *cmdline; /* concatenated argv */
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
} SemihostingConfig;

static SemihostingConfig semihosting;

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

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

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 1363 1364 1365 1366 1367
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, " ");
    }
}

1368 1369 1370 1371 1372 1373 1374
/* 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 已提交
1375 1376 1377
/***********************************************************/
/* USB devices */

1378
static int usb_device_add(const char *devname)
B
bellard 已提交
1379
{
1380
    USBDevice *dev = NULL;
1381 1382 1383
#ifndef CONFIG_LINUX
    const char *p;
#endif
B
bellard 已提交
1384

1385
    if (!usb_enabled()) {
B
bellard 已提交
1386
        return -1;
1387
    }
B
bellard 已提交
1388

G
Gerd Hoffmann 已提交
1389 1390 1391 1392 1393
    /* drivers with .usbdevice_name entry in USBDeviceInfo */
    dev = usbdevice_create(devname);
    if (dev)
        goto done;

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

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

1408 1409 1410 1411 1412
static int usb_device_del(const char *devname)
{
    int bus_num, addr;
    const char *p;

1413 1414 1415
    if (strstart(devname, "host:", &p)) {
        return -1;
    }
1416

1417
    if (!usb_enabled()) {
1418
        return -1;
1419
    }
1420 1421 1422 1423 1424 1425 1426

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

1427
    return usb_device_delete_addr(bus_num, addr);
1428 1429
}

1430 1431
static int usb_parse(const char *cmdline)
{
S
Scott Tsai 已提交
1432
    int r;
1433
    r = usb_device_add(cmdline);
S
Scott Tsai 已提交
1434
    if (r < 0) {
1435
        error_report("could not add USB device '%s'", cmdline);
S
Scott Tsai 已提交
1436 1437
    }
    return r;
1438 1439
}

1440
void hmp_usb_add(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1441
{
S
Scott Tsai 已提交
1442
    const char *devname = qdict_get_str(qdict, "devname");
1443
    if (usb_device_add(devname) < 0) {
1444
        error_report("could not add USB device '%s'", devname);
S
Scott Tsai 已提交
1445
    }
B
bellard 已提交
1446 1447
}

1448
void hmp_usb_del(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1449
{
S
Scott Tsai 已提交
1450 1451
    const char *devname = qdict_get_str(qdict, "devname");
    if (usb_device_del(devname) < 0) {
1452
        error_report("could not delete USB device '%s'", devname);
S
Scott Tsai 已提交
1453
    }
B
bellard 已提交
1454 1455
}

1456 1457 1458
/***********************************************************/
/* machine registration */

1459
MachineState *current_machine;
1460

1461
static MachineClass *find_machine(const char *name)
1462
{
1463
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1464
    MachineClass *mc = NULL;
1465

1466
    for (el = machines; el; el = el->next) {
1467
        MachineClass *temp = el->data;
1468

1469
        if (!strcmp(temp->name, name)) {
1470
            mc = temp;
1471 1472
            break;
        }
1473 1474
        if (temp->alias &&
            !strcmp(temp->alias, name)) {
1475
            mc = temp;
1476 1477
            break;
        }
1478
    }
1479 1480

    g_slist_free(machines);
1481
    return mc;
1482 1483
}

1484
MachineClass *find_default_machine(void)
1485
{
1486
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1487
    MachineClass *mc = NULL;
1488

1489
    for (el = machines; el; el = el->next) {
1490
        MachineClass *temp = el->data;
1491

1492
        if (temp->is_default) {
1493
            mc = temp;
1494
            break;
1495 1496
        }
    }
1497 1498

    g_slist_free(machines);
1499
    return mc;
1500 1501
}

1502 1503
MachineInfoList *qmp_query_machines(Error **errp)
{
1504
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
1505 1506
    MachineInfoList *mach_list = NULL;

1507 1508
    for (el = machines; el; el = el->next) {
        MachineClass *mc = el->data;
1509 1510 1511 1512
        MachineInfoList *entry;
        MachineInfo *info;

        info = g_malloc0(sizeof(*info));
1513
        if (mc->is_default) {
1514 1515 1516 1517
            info->has_is_default = true;
            info->is_default = true;
        }

1518
        if (mc->alias) {
1519
            info->has_alias = true;
1520
            info->alias = g_strdup(mc->alias);
1521 1522
        }

1523 1524
        info->name = g_strdup(mc->name);
        info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
1525 1526 1527 1528 1529 1530 1531

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

1532
    g_slist_free(machines);
1533 1534 1535
    return mach_list;
}

M
Marcel Apfelbaum 已提交
1536 1537 1538
static int machine_help_func(QemuOpts *opts, MachineState *machine)
{
    ObjectProperty *prop;
1539
    ObjectPropertyIterator *iter;
M
Marcel Apfelbaum 已提交
1540 1541 1542 1543 1544

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

1545 1546
    iter = object_property_iter_init(OBJECT(machine));
    while ((prop = object_property_iter_next(iter))) {
M
Marcel Apfelbaum 已提交
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");
        }
    }
1559
    object_property_iter_free(iter);
M
Marcel Apfelbaum 已提交
1560 1561 1562 1563

    return 1;
}

1564 1565 1566
/***********************************************************/
/* main execution loop */

B
bellard 已提交
1567 1568 1569
struct vm_change_state_entry {
    VMChangeStateHandler *cb;
    void *opaque;
B
Blue Swirl 已提交
1570
    QLIST_ENTRY (vm_change_state_entry) entries;
B
bellard 已提交
1571 1572
};

B
Blue Swirl 已提交
1573
static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
B
bellard 已提交
1574 1575 1576 1577 1578 1579

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

1580
    e = g_malloc0(sizeof (*e));
B
bellard 已提交
1581 1582 1583

    e->cb = cb;
    e->opaque = opaque;
B
Blue Swirl 已提交
1584
    QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
B
bellard 已提交
1585 1586 1587 1588 1589
    return e;
}

void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
{
B
Blue Swirl 已提交
1590
    QLIST_REMOVE (e, entries);
1591
    g_free (e);
B
bellard 已提交
1592 1593
}

1594
void vm_state_notify(int running, RunState state)
B
bellard 已提交
1595
{
1596
    VMChangeStateEntry *e, *next;
B
bellard 已提交
1597

1598
    trace_vm_state_notify(running, state);
1599

1600
    QLIST_FOREACH_SAFE(e, &vm_change_state_head, entries, next) {
1601
        e->cb(e->opaque, running, state);
B
bellard 已提交
1602 1603 1604
    }
}

1605 1606 1607
/* reset/shutdown handler */

typedef struct QEMUResetEntry {
B
Blue Swirl 已提交
1608
    QTAILQ_ENTRY(QEMUResetEntry) entry;
1609 1610 1611 1612
    QEMUResetHandler *func;
    void *opaque;
} QEMUResetEntry;

B
Blue Swirl 已提交
1613 1614
static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
    QTAILQ_HEAD_INITIALIZER(reset_handlers);
1615
static int reset_requested;
1616 1617
static int shutdown_requested, shutdown_signal = -1;
static pid_t shutdown_pid;
B
bellard 已提交
1618
static int powerdown_requested;
1619
static int debug_requested;
G
Gerd Hoffmann 已提交
1620
static int suspend_requested;
L
Liu, Jinsong 已提交
1621
static WakeupReason wakeup_reason;
I
Igor Mammedov 已提交
1622 1623
static NotifierList powerdown_notifiers =
    NOTIFIER_LIST_INITIALIZER(powerdown_notifiers);
G
Gerd Hoffmann 已提交
1624 1625 1626 1627
static NotifierList suspend_notifiers =
    NOTIFIER_LIST_INITIALIZER(suspend_notifiers);
static NotifierList wakeup_notifiers =
    NOTIFIER_LIST_INITIALIZER(wakeup_notifiers);
L
Liu, Jinsong 已提交
1628
static uint32_t wakeup_reason_mask = ~(1 << QEMU_WAKEUP_REASON_NONE);
1629

1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
int qemu_shutdown_requested_get(void)
{
    return shutdown_requested;
}

int qemu_reset_requested_get(void)
{
    return reset_requested;
}

B
Blue Swirl 已提交
1640
static int qemu_shutdown_requested(void)
A
aurel32 已提交
1641
{
1642
    return atomic_xchg(&shutdown_requested, 0);
A
aurel32 已提交
1643 1644
}

B
Blue Swirl 已提交
1645
static void qemu_kill_report(void)
1646
{
1647
    if (!qtest_driver() && shutdown_signal != -1) {
1648 1649 1650 1651
        if (shutdown_pid == 0) {
            /* This happens for eg ^C at the terminal, so it's worth
             * avoiding printing an odd message in that case.
             */
1652
            error_report("terminating on signal %d", shutdown_signal);
1653
        } else {
1654 1655
            error_report("terminating on signal %d from pid " FMT_pid,
                         shutdown_signal, shutdown_pid);
1656
        }
1657 1658 1659 1660
        shutdown_signal = -1;
    }
}

B
Blue Swirl 已提交
1661
static int qemu_reset_requested(void)
A
aurel32 已提交
1662 1663
{
    int r = reset_requested;
P
Pavel Dovgalyuk 已提交
1664 1665 1666 1667 1668
    if (r && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) {
        reset_requested = 0;
        return r;
    }
    return false;
A
aurel32 已提交
1669 1670
}

G
Gerd Hoffmann 已提交
1671 1672 1673
static int qemu_suspend_requested(void)
{
    int r = suspend_requested;
P
Pavel Dovgalyuk 已提交
1674 1675 1676 1677 1678
    if (r && replay_checkpoint(CHECKPOINT_SUSPEND_REQUESTED)) {
        suspend_requested = 0;
        return r;
    }
    return false;
G
Gerd Hoffmann 已提交
1679 1680
}

L
Liu, Jinsong 已提交
1681
static WakeupReason qemu_wakeup_requested(void)
1682
{
L
Liu, Jinsong 已提交
1683
    return wakeup_reason;
1684 1685
}

B
Blue Swirl 已提交
1686
static int qemu_powerdown_requested(void)
A
aurel32 已提交
1687 1688 1689 1690 1691 1692
{
    int r = powerdown_requested;
    powerdown_requested = 0;
    return r;
}

1693 1694 1695 1696 1697 1698 1699
static int qemu_debug_requested(void)
{
    int r = debug_requested;
    debug_requested = 0;
    return r;
}

1700
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
1701
{
1702
    QEMUResetEntry *re = g_malloc0(sizeof(QEMUResetEntry));
1703 1704 1705

    re->func = func;
    re->opaque = opaque;
B
Blue Swirl 已提交
1706
    QTAILQ_INSERT_TAIL(&reset_handlers, re, entry);
1707 1708
}

J
Jan Kiszka 已提交
1709
void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
1710 1711 1712
{
    QEMUResetEntry *re;

B
Blue Swirl 已提交
1713
    QTAILQ_FOREACH(re, &reset_handlers, entry) {
J
Jan Kiszka 已提交
1714
        if (re->func == func && re->opaque == opaque) {
B
Blue Swirl 已提交
1715
            QTAILQ_REMOVE(&reset_handlers, re, entry);
1716
            g_free(re);
J
Jan Kiszka 已提交
1717 1718 1719 1720 1721
            return;
        }
    }
}

1722
void qemu_devices_reset(void)
J
Jan Kiszka 已提交
1723 1724 1725 1726
{
    QEMUResetEntry *re, *nre;

    /* reset all devices */
B
Blue Swirl 已提交
1727
    QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
1728 1729
        re->func(re->opaque);
    }
1730 1731 1732 1733
}

void qemu_system_reset(bool report)
{
1734 1735 1736 1737
    MachineClass *mc;

    mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;

1738 1739
    if (mc && mc->reset) {
        mc->reset();
1740 1741 1742
    } else {
        qemu_devices_reset();
    }
J
Jan Kiszka 已提交
1743
    if (report) {
W
Wenchao Xia 已提交
1744
        qapi_event_send_reset(&error_abort);
J
Jan Kiszka 已提交
1745
    }
1746
    cpu_synchronize_all_post_reset();
1747 1748
}

1749 1750
void qemu_system_guest_panicked(void)
{
1751 1752 1753
    if (current_cpu) {
        current_cpu->crash_occurred = true;
    }
1754 1755 1756 1757
    qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, &error_abort);
    vm_stop(RUN_STATE_GUEST_PANICKED);
}

1758 1759
void qemu_system_reset_request(void)
{
B
bellard 已提交
1760 1761 1762 1763 1764
    if (no_reboot) {
        shutdown_requested = 1;
    } else {
        reset_requested = 1;
    }
1765
    cpu_stop_current();
1766
    qemu_notify_event();
1767 1768
}

G
Gerd Hoffmann 已提交
1769 1770 1771 1772
static void qemu_system_suspend(void)
{
    pause_all_vcpus();
    notifier_list_notify(&suspend_notifiers, NULL);
1773
    runstate_set(RUN_STATE_SUSPENDED);
W
Wenchao Xia 已提交
1774
    qapi_event_send_suspend(&error_abort);
G
Gerd Hoffmann 已提交
1775 1776 1777 1778
}

void qemu_system_suspend_request(void)
{
L
Luiz Capitulino 已提交
1779
    if (runstate_check(RUN_STATE_SUSPENDED)) {
G
Gerd Hoffmann 已提交
1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
        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)
{
1794 1795
    trace_system_wakeup_request(reason);

L
Luiz Capitulino 已提交
1796
    if (!runstate_check(RUN_STATE_SUSPENDED)) {
G
Gerd Hoffmann 已提交
1797 1798 1799 1800 1801
        return;
    }
    if (!(wakeup_reason_mask & (1 << reason))) {
        return;
    }
1802
    runstate_set(RUN_STATE_RUNNING);
L
Liu, Jinsong 已提交
1803
    wakeup_reason = reason;
G
Gerd Hoffmann 已提交
1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820
    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);
}

1821 1822 1823 1824
void qemu_system_killed(int signal, pid_t pid)
{
    shutdown_signal = signal;
    shutdown_pid = pid;
1825
    no_shutdown = 0;
P
Pavel Dovgalyuk 已提交
1826 1827 1828 1829 1830 1831

    /* Cannot call qemu_system_shutdown_request directly because
     * we are in a signal handler.
     */
    shutdown_requested = 1;
    qemu_notify_event();
1832 1833
}

1834 1835
void qemu_system_shutdown_request(void)
{
1836
    trace_qemu_system_shutdown_request();
P
Pavel Dovgalyuk 已提交
1837
    replay_shutdown_request();
1838
    shutdown_requested = 1;
1839
    qemu_notify_event();
1840 1841
}

1842 1843
static void qemu_system_powerdown(void)
{
W
Wenchao Xia 已提交
1844
    qapi_event_send_powerdown(&error_abort);
1845 1846 1847
    notifier_list_notify(&powerdown_notifiers, NULL);
}

B
bellard 已提交
1848 1849
void qemu_system_powerdown_request(void)
{
1850
    trace_qemu_system_powerdown_request();
B
bellard 已提交
1851
    powerdown_requested = 1;
1852 1853 1854
    qemu_notify_event();
}

I
Igor Mammedov 已提交
1855 1856 1857 1858 1859
void qemu_register_powerdown_notifier(Notifier *notifier)
{
    notifier_list_add(&powerdown_notifiers, notifier);
}

1860 1861 1862
void qemu_system_debug_request(void)
{
    debug_requested = 1;
1863
    qemu_notify_event();
1864 1865
}

P
Paolo Bonzini 已提交
1866 1867 1868 1869 1870 1871
static bool main_loop_should_exit(void)
{
    RunState r;
    if (qemu_debug_requested()) {
        vm_stop(RUN_STATE_DEBUG);
    }
G
Gerd Hoffmann 已提交
1872 1873 1874
    if (qemu_suspend_requested()) {
        qemu_system_suspend();
    }
P
Paolo Bonzini 已提交
1875 1876
    if (qemu_shutdown_requested()) {
        qemu_kill_report();
W
Wenchao Xia 已提交
1877
        qapi_event_send_shutdown(&error_abort);
P
Paolo Bonzini 已提交
1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888
        if (no_shutdown) {
            vm_stop(RUN_STATE_SHUTDOWN);
        } else {
            return true;
        }
    }
    if (qemu_reset_requested()) {
        pause_all_vcpus();
        cpu_synchronize_all_states();
        qemu_system_reset(VMRESET_REPORT);
        resume_all_vcpus();
1889
        if (runstate_needs_reset()) {
P
Paolo Bonzini 已提交
1890 1891 1892
            runstate_set(RUN_STATE_PAUSED);
        }
    }
1893 1894 1895 1896
    if (qemu_wakeup_requested()) {
        pause_all_vcpus();
        cpu_synchronize_all_states();
        qemu_system_reset(VMRESET_SILENT);
L
Liu, Jinsong 已提交
1897 1898
        notifier_list_notify(&wakeup_notifiers, &wakeup_reason);
        wakeup_reason = QEMU_WAKEUP_REASON_NONE;
1899
        resume_all_vcpus();
W
Wenchao Xia 已提交
1900
        qapi_event_send_wakeup(&error_abort);
1901
    }
P
Paolo Bonzini 已提交
1902
    if (qemu_powerdown_requested()) {
1903
        qemu_system_powerdown();
P
Paolo Bonzini 已提交
1904 1905 1906 1907 1908 1909 1910
    }
    if (qemu_vmstop_requested(&r)) {
        vm_stop(r);
    }
    return false;
}

1911 1912
static void main_loop(void)
{
1913
    bool nonblocking;
P
Paolo Bonzini 已提交
1914
    int last_io = 0;
1915 1916 1917
#ifdef CONFIG_PROFILER
    int64_t ti;
#endif
P
Paolo Bonzini 已提交
1918
    do {
1919
        nonblocking = !kvm_enabled() && !xen_enabled() && last_io > 0;
1920
#ifdef CONFIG_PROFILER
J
Jan Kiszka 已提交
1921
        ti = profile_getclock();
1922
#endif
1923
        last_io = main_loop_wait(nonblocking);
1924
#ifdef CONFIG_PROFILER
J
Jan Kiszka 已提交
1925
        dev_time += profile_getclock() - ti;
1926
#endif
P
Paolo Bonzini 已提交
1927
    } while (!main_loop_should_exit());
B
bellard 已提交
1928 1929
}

P
pbrook 已提交
1930 1931
static void version(void)
{
T
Thomas Monjalon 已提交
1932
    printf("QEMU emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
P
pbrook 已提交
1933 1934
}

1935
static void help(int exitcode)
1936
{
1937 1938 1939 1940 1941
    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());

1942 1943
#define QEMU_OPTIONS_GENERATE_HELP
#include "qemu-options-wrapper.h"
1944 1945

    printf("\nDuring emulation, the following keys are useful:\n"
1946 1947 1948 1949
           "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"
1950 1951
           "When using -nographic, press 'ctrl-a h' to get some help.\n");

1952
    exit(exitcode);
1953 1954
}

1955 1956 1957 1958 1959 1960
#define HAS_ARG 0x0001

typedef struct QEMUOption {
    const char *name;
    int flags;
    int index;
1961
    uint32_t arch_mask;
1962 1963
} QEMUOption;

B
blueswir1 已提交
1964
static const QEMUOption qemu_options[] = {
1965
    { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
1966 1967
#define QEMU_OPTIONS_GENERATE_OPTIONS
#include "qemu-options-wrapper.h"
1968
    { NULL },
B
bellard 已提交
1969
};
B
Blue Swirl 已提交
1970 1971 1972

static bool vga_available(void)
{
1973
    return object_class_by_name("VGA") || object_class_by_name("isa-vga");
B
Blue Swirl 已提交
1974 1975 1976 1977
}

static bool cirrus_vga_available(void)
{
1978 1979
    return object_class_by_name("cirrus-vga")
           || object_class_by_name("isa-cirrus-vga");
B
Blue Swirl 已提交
1980 1981 1982 1983
}

static bool vmware_vga_available(void)
{
1984
    return object_class_by_name("vmware-svga");
B
Blue Swirl 已提交
1985 1986
}

A
Aurelien Jarno 已提交
1987 1988 1989 1990 1991
static bool qxl_vga_available(void)
{
    return object_class_by_name("qxl-vga");
}

1992 1993 1994 1995 1996 1997 1998 1999 2000 2001
static bool tcx_vga_available(void)
{
    return object_class_by_name("SUNW,tcx");
}

static bool cg3_vga_available(void)
{
    return object_class_by_name("cgthree");
}

2002 2003 2004 2005 2006
static bool virtio_vga_available(void)
{
    return object_class_by_name("virtio-vga");
}

2007 2008 2009 2010
static void select_vgahw (const char *p)
{
    const char *opts;

2011
    assert(vga_interface_type == VGA_NONE);
2012
    if (strstart(p, "std", &opts)) {
B
Blue Swirl 已提交
2013 2014 2015
        if (vga_available()) {
            vga_interface_type = VGA_STD;
        } else {
2016
            error_report("standard VGA not available");
B
Blue Swirl 已提交
2017 2018
            exit(0);
        }
2019
    } else if (strstart(p, "cirrus", &opts)) {
B
Blue Swirl 已提交
2020 2021 2022
        if (cirrus_vga_available()) {
            vga_interface_type = VGA_CIRRUS;
        } else {
2023
            error_report("Cirrus VGA not available");
B
Blue Swirl 已提交
2024 2025
            exit(0);
        }
2026
    } else if (strstart(p, "vmware", &opts)) {
B
Blue Swirl 已提交
2027 2028 2029
        if (vmware_vga_available()) {
            vga_interface_type = VGA_VMWARE;
        } else {
2030
            error_report("VMWare SVGA not available");
B
Blue Swirl 已提交
2031 2032
            exit(0);
        }
2033 2034 2035 2036
    } else if (strstart(p, "virtio", &opts)) {
        if (virtio_vga_available()) {
            vga_interface_type = VGA_VIRTIO;
        } else {
2037
            error_report("Virtio VGA not available");
2038 2039
            exit(0);
        }
2040
    } else if (strstart(p, "xenfb", &opts)) {
2041
        vga_interface_type = VGA_XENFB;
G
Gerd Hoffmann 已提交
2042
    } else if (strstart(p, "qxl", &opts)) {
A
Aurelien Jarno 已提交
2043 2044 2045
        if (qxl_vga_available()) {
            vga_interface_type = VGA_QXL;
        } else {
2046
            error_report("QXL VGA not available");
A
Aurelien Jarno 已提交
2047 2048
            exit(0);
        }
2049 2050 2051 2052
    } else if (strstart(p, "tcx", &opts)) {
        if (tcx_vga_available()) {
            vga_interface_type = VGA_TCX;
        } else {
2053
            error_report("TCX framebuffer not available");
2054 2055 2056 2057 2058 2059
            exit(0);
        }
    } else if (strstart(p, "cg3", &opts)) {
        if (cg3_vga_available()) {
            vga_interface_type = VGA_CG3;
        } else {
2060
            error_report("CG3 framebuffer not available");
2061 2062
            exit(0);
        }
2063
    } else if (!strstart(p, "none", &opts)) {
2064
    invalid_vga:
2065
        error_report("unknown vga type: %s", p);
2066 2067
        exit(1);
    }
M
malc 已提交
2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080
    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;
    }
2081 2082
}

J
Jes Sorensen 已提交
2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
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 {
2101
                    goto invalid_sdl_args;
J
Jes Sorensen 已提交
2102 2103 2104 2105 2106 2107 2108 2109
                }
            } 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 {
2110
                    goto invalid_sdl_args;
J
Jes Sorensen 已提交
2111 2112 2113 2114 2115 2116 2117 2118
                }
            } 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 {
2119
                    goto invalid_sdl_args;
J
Jes Sorensen 已提交
2120 2121 2122 2123 2124 2125 2126 2127
                }
            } 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 {
2128
                    goto invalid_sdl_args;
J
Jes Sorensen 已提交
2129
                }
2130 2131 2132 2133 2134 2135 2136 2137 2138
            } 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;
                }
J
Jes Sorensen 已提交
2139
            } else {
2140
            invalid_sdl_args:
2141
                error_report("invalid SDL option string");
2142
                exit(1);
J
Jes Sorensen 已提交
2143 2144 2145 2146
            }
            opts = nextopt;
        }
#else
2147
        error_report("SDL support is disabled");
J
Jes Sorensen 已提交
2148 2149
        exit(1);
#endif
J
Jes Sorensen 已提交
2150
    } else if (strstart(p, "vnc", &opts)) {
J
Jes Sorensen 已提交
2151
#ifdef CONFIG_VNC
2152
        if (*opts == '=') {
2153
            Error *err = NULL;
2154 2155
            if (vnc_parse(opts + 1, &err) == NULL) {
                error_report_err(err);
2156
                exit(1);
J
Jes Sorensen 已提交
2157
            }
2158
        } else {
2159
            error_report("VNC requires a display argument vnc=<display>");
J
Jes Sorensen 已提交
2160 2161
            exit(1);
        }
J
Jes Sorensen 已提交
2162
#else
2163
        error_report("VNC support is disabled");
J
Jes Sorensen 已提交
2164 2165
        exit(1);
#endif
J
Jes Sorensen 已提交
2166 2167 2168 2169
    } else if (strstart(p, "curses", &opts)) {
#ifdef CONFIG_CURSES
        display = DT_CURSES;
#else
2170
        error_report("curses support is disabled");
J
Jes Sorensen 已提交
2171
        exit(1);
A
Anthony Liguori 已提交
2172 2173 2174 2175
#endif
    } else if (strstart(p, "gtk", &opts)) {
#ifdef CONFIG_GTK
        display = DT_GTK;
2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187
        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;
                }
2188 2189 2190 2191 2192 2193 2194 2195 2196
            } 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;
                }
2197 2198
            } else {
            invalid_gtk_args:
2199
                error_report("invalid GTK option string");
2200 2201 2202 2203
                exit(1);
            }
            opts = nextopt;
        }
A
Anthony Liguori 已提交
2204
#else
2205
        error_report("GTK support is disabled");
A
Anthony Liguori 已提交
2206
        exit(1);
J
Jes Sorensen 已提交
2207
#endif
J
Jes Sorensen 已提交
2208 2209
    } else if (strstart(p, "none", &opts)) {
        display = DT_NONE;
J
Jes Sorensen 已提交
2210
    } else {
2211
        error_report("unknown display type");
J
Jes Sorensen 已提交
2212 2213 2214 2215 2216 2217
        exit(1);
    }

    return display;
}

2218 2219
static int balloon_parse(const char *arg)
{
2220
    QemuOpts *opts;
2221

2222 2223 2224 2225 2226 2227 2228
    if (strcmp(arg, "none") == 0) {
        return 0;
    }

    if (!strncmp(arg, "virtio", 6)) {
        if (arg[6] == ',') {
            /* have params -> parse them */
2229 2230
            opts = qemu_opts_parse_noisily(qemu_find_opts("device"), arg + 7,
                                           false);
2231 2232 2233 2234
            if (!opts)
                return  -1;
        } else {
            /* create empty opts */
2235 2236
            opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                    &error_abort);
2237
        }
2238
        qemu_opt_set(opts, "driver", "virtio-balloon", &error_abort);
2239
        return 0;
2240
    }
2241 2242

    return -1;
2243 2244
}

P
Paul Brook 已提交
2245 2246
char *qemu_find_file(int type, const char *name)
{
2247
    int i;
P
Paul Brook 已提交
2248 2249 2250
    const char *subdir;
    char *buf;

2251 2252
    /* Try the name as a straight path first */
    if (access(name, R_OK) == 0) {
2253
        trace_load_file(name, name);
2254
        return g_strdup(name);
P
Paul Brook 已提交
2255
    }
2256

P
Paul Brook 已提交
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266
    switch (type) {
    case QEMU_FILE_TYPE_BIOS:
        subdir = "";
        break;
    case QEMU_FILE_TYPE_KEYMAP:
        subdir = "keymaps/";
        break;
    default:
        abort();
    }
2267 2268 2269 2270 2271 2272 2273

    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;
        }
2274
        g_free(buf);
P
Paul Brook 已提交
2275
    }
2276
    return NULL;
P
Paul Brook 已提交
2277 2278
}

2279 2280 2281 2282 2283
static inline bool nonempty_str(const char *str)
{
    return str && *str;
}

2284 2285 2286 2287
static int parse_fw_cfg(void *opaque, QemuOpts *opts, Error **errp)
{
    gchar *buf;
    size_t size;
2288
    const char *name, *file, *str;
2289 2290 2291 2292 2293 2294 2295

    if (opaque == NULL) {
        error_report("fw_cfg device not available");
        return -1;
    }
    name = qemu_opt_get(opts, "name");
    file = qemu_opt_get(opts, "file");
2296 2297 2298 2299 2300 2301 2302 2303 2304
    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");
2305 2306 2307 2308 2309 2310 2311
        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) {
2312
        error_report("warning: externally provided fw_cfg item names "
2313
                     "should be prefixed with \"opt/\"");
2314
    }
2315 2316 2317 2318 2319 2320 2321 2322
    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;
        }
2323 2324 2325 2326 2327
    }
    fw_cfg_add_file((FWCfgState *)opaque, name, buf, size);
    return 0;
}

2328
static int device_help_func(void *opaque, QemuOpts *opts, Error **errp)
2329 2330 2331 2332
{
    return qdev_device_help(opts);
}

2333
static int device_init_func(void *opaque, QemuOpts *opts, Error **errp)
G
Gerd Hoffmann 已提交
2334
{
2335
    Error *err = NULL;
G
Gerd Hoffmann 已提交
2336 2337
    DeviceState *dev;

2338 2339 2340
    dev = qdev_device_add(opts, &err);
    if (!dev) {
        error_report_err(err);
G
Gerd Hoffmann 已提交
2341
        return -1;
2342
    }
2343
    object_unref(OBJECT(dev));
G
Gerd Hoffmann 已提交
2344 2345 2346
    return 0;
}

2347
static int chardev_init_func(void *opaque, QemuOpts *opts, Error **errp)
2348
{
2349
    Error *local_err = NULL;
2350

2351
    qemu_chr_new_from_opts(opts, NULL, &local_err);
2352
    if (local_err) {
2353
        error_report_err(local_err);
2354
        return -1;
2355
    }
2356 2357 2358
    return 0;
}

2359
#ifdef CONFIG_VIRTFS
2360
static int fsdev_init_func(void *opaque, QemuOpts *opts, Error **errp)
2361 2362 2363 2364 2365 2366 2367 2368
{
    int ret;
    ret = qemu_fsdev_add(opts);

    return ret;
}
#endif

2369
static int mon_init_func(void *opaque, QemuOpts *opts, Error **errp)
2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384
{
    CharDriverState *chr;
    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 {
2385
        error_report("unknown monitor mode \"%s\"", mode);
2386 2387 2388
        exit(1);
    }

2389 2390 2391
    if (qemu_opt_get_bool(opts, "pretty", 0))
        flags |= MONITOR_USE_PRETTY;

2392 2393 2394 2395 2396 2397
    if (qemu_opt_get_bool(opts, "default", 0))
        flags |= MONITOR_IS_DEFAULT;

    chardev = qemu_opt_get(opts, "chardev");
    chr = qemu_chr_find(chardev);
    if (chr == NULL) {
2398
        error_report("chardev \"%s\" not found", chardev);
2399 2400 2401
        exit(1);
    }

2402
    qemu_chr_fe_claim_no_fail(chr);
2403 2404 2405 2406
    monitor_init(chr, flags);
    return 0;
}

M
Max Reitz 已提交
2407
static void monitor_parse(const char *optarg, const char *mode, bool pretty)
2408 2409
{
    static int monitor_device_index = 0;
2410
    Error *local_err = NULL;
2411 2412 2413 2414 2415 2416 2417 2418
    QemuOpts *opts;
    const char *p;
    char label[32];
    int def = 0;

    if (strstart(optarg, "chardev:", &p)) {
        snprintf(label, sizeof(label), "%s", p);
    } else {
2419 2420 2421
        snprintf(label, sizeof(label), "compat_monitor%d",
                 monitor_device_index);
        if (monitor_device_index == 0) {
2422 2423 2424 2425
            def = 1;
        }
        opts = qemu_chr_parse_compat(label, optarg);
        if (!opts) {
2426
            error_report("parse error: %s", optarg);
2427 2428 2429 2430
            exit(1);
        }
    }

2431
    opts = qemu_opts_create(qemu_find_opts("mon"), label, 1, &local_err);
2432
    if (!opts) {
2433
        error_report_err(local_err);
2434 2435
        exit(1);
    }
2436 2437
    qemu_opt_set(opts, "mode", mode, &error_abort);
    qemu_opt_set(opts, "chardev", label, &error_abort);
2438
    qemu_opt_set_bool(opts, "pretty", pretty, &error_abort);
2439
    if (def)
2440
        qemu_opt_set(opts, "default", "on", &error_abort);
2441 2442 2443
    monitor_device_index++;
}

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

static QTAILQ_HEAD(, device_config) device_configs =
    QTAILQ_HEAD_INITIALIZER(device_configs);
2462 2463 2464 2465 2466

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

2467
    conf = g_malloc0(sizeof(*conf));
2468 2469
    conf->type = type;
    conf->cmdline = cmdline;
2470
    loc_save(&conf->loc);
B
Blue Swirl 已提交
2471
    QTAILQ_INSERT_TAIL(&device_configs, conf, next);
2472 2473 2474 2475 2476 2477 2478
}

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

B
Blue Swirl 已提交
2479
    QTAILQ_FOREACH(conf, &device_configs, next) {
2480 2481
        if (conf->type != type)
            continue;
2482
        loc_push_restore(&conf->loc);
2483
        rc = func(conf->cmdline);
2484
        loc_pop(&conf->loc);
G
Gonglei 已提交
2485
        if (rc) {
2486
            return rc;
G
Gonglei 已提交
2487
        }
2488 2489 2490 2491
    }
    return 0;
}

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

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

G
Gerd Hoffmann 已提交
2536 2537
static int virtcon_parse(const char *devname)
{
2538
    QemuOptsList *device = qemu_find_opts("device");
G
Gerd Hoffmann 已提交
2539 2540
    static int index = 0;
    char label[32];
2541
    QemuOpts *bus_opts, *dev_opts;
G
Gerd Hoffmann 已提交
2542 2543 2544 2545

    if (strcmp(devname, "none") == 0)
        return 0;
    if (index == MAX_VIRTIO_CONSOLES) {
2546
        error_report("too many virtio consoles");
G
Gerd Hoffmann 已提交
2547 2548
        exit(1);
    }
2549

2550
    bus_opts = qemu_opts_create(device, NULL, 0, &error_abort);
2551
    if (arch_type == QEMU_ARCH_S390X) {
2552
        qemu_opt_set(bus_opts, "driver", "virtio-serial-s390", &error_abort);
2553
    } else {
2554
        qemu_opt_set(bus_opts, "driver", "virtio-serial-pci", &error_abort);
L
Laszlo Ersek 已提交
2555
    }
2556

2557
    dev_opts = qemu_opts_create(device, NULL, 0, &error_abort);
2558
    qemu_opt_set(dev_opts, "driver", "virtconsole", &error_abort);
2559

G
Gerd Hoffmann 已提交
2560
    snprintf(label, sizeof(label), "virtcon%d", index);
2561
    virtcon_hds[index] = qemu_chr_new(label, devname, NULL);
G
Gerd Hoffmann 已提交
2562
    if (!virtcon_hds[index]) {
2563 2564
        error_report("could not connect virtio console"
                     " to character backend '%s'", devname);
G
Gerd Hoffmann 已提交
2565 2566
        return -1;
    }
2567
    qemu_opt_set(dev_opts, "chardev", label, &error_abort);
2568

G
Gerd Hoffmann 已提交
2569 2570 2571 2572
    index++;
    return 0;
}

2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583
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) {
2584
        error_report("too many sclp consoles");
2585 2586 2587 2588 2589 2590
        exit(1);
    }

    assert(arch_type == QEMU_ARCH_S390X);

    dev_opts = qemu_opts_create(device, NULL, 0, NULL);
2591
    qemu_opt_set(dev_opts, "driver", "sclpconsole", &error_abort);
2592 2593 2594 2595

    snprintf(label, sizeof(label), "sclpcon%d", index);
    sclp_hds[index] = qemu_chr_new(label, devname, NULL);
    if (!sclp_hds[index]) {
2596 2597
        error_report("could not connect sclp console"
                     " to character backend '%s'", devname);
2598 2599
        return -1;
    }
2600
    qemu_opt_set(dev_opts, "chardev", label, &error_abort);
2601 2602 2603 2604 2605

    index++;
    return 0;
}

2606
static int debugcon_parse(const char *devname)
L
Laszlo Ersek 已提交
2607
{
2608 2609
    QemuOpts *opts;

2610
    if (!qemu_chr_new("debugcon", devname, NULL)) {
2611 2612
        exit(1);
    }
2613
    opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL);
2614
    if (!opts) {
2615
        error_report("already have a debugcon device");
2616 2617
        exit(1);
    }
2618 2619
    qemu_opt_set(opts, "driver", "isa-debugcon", &error_abort);
    qemu_opt_set(opts, "chardev", "debugcon", &error_abort);
2620 2621 2622
    return 0;
}

2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657
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)
2658
{
2659
    MachineClass *mc = NULL;
2660
    GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
2661 2662

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

    g_slist_free(machines);
2686
    exit(!name || !is_help_option(name));
2687 2688
}

G
Gerd Hoffmann 已提交
2689 2690 2691 2692 2693 2694 2695
void qemu_add_exit_notifier(Notifier *notify)
{
    notifier_list_add(&exit_notifiers, notify);
}

void qemu_remove_exit_notifier(Notifier *notify)
{
P
Paolo Bonzini 已提交
2696
    notifier_remove(notify);
G
Gerd Hoffmann 已提交
2697 2698 2699 2700
}

static void qemu_run_exit_notifiers(void)
{
2701
    notifier_list_notify(&exit_notifiers, NULL);
G
Gerd Hoffmann 已提交
2702 2703
}

2704 2705
static bool machine_init_done;

2706 2707 2708
void qemu_add_machine_init_done_notifier(Notifier *notify)
{
    notifier_list_add(&machine_init_done_notifiers, notify);
2709 2710 2711
    if (machine_init_done) {
        notify->notify(notify, NULL);
    }
2712 2713 2714 2715
}

static void qemu_run_machine_init_done_notifiers(void)
{
2716
    notifier_list_notify(&machine_init_done_notifiers, NULL);
2717
    machine_init_done = true;
2718 2719
}

2720 2721 2722 2723 2724 2725 2726 2727
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;

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

    *poptarg = optarg;
    *poptind = optind;

    return popt;
}

2760 2761 2762
static int machine_set_property(void *opaque,
                                const char *name, const char *value,
                                Error **errp)
2763 2764 2765
{
    Object *obj = OBJECT(opaque);
    Error *local_err = NULL;
2766
    char *c, *qom_name;
2767

2768
    if (strcmp(name, "type") == 0) {
2769 2770 2771
        return 0;
    }

2772 2773 2774 2775 2776 2777 2778 2779
    qom_name = g_strdup(name);
    c = qom_name;
    while (*c++) {
        if (*c == '_') {
            *c = '-';
        }
    }

2780
    object_property_parse(obj, value, qom_name, &local_err);
2781
    g_free(qom_name);
2782 2783

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

    return 0;
}

2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803

/*
 * 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;
    }
Y
Yang Hongyang 已提交
2804

2805 2806 2807 2808 2809 2810
    /*
     * return false for concrete netfilters since
     * they depend on netdevs already existing
     */
    if (g_str_equal(type, "filter-buffer") ||
        g_str_equal(type, "filter-dump")) {
Y
Yang Hongyang 已提交
2811 2812 2813
        return false;
    }

2814 2815 2816 2817 2818 2819
    return true;
}


/*
 * The remainder of object creation happens after the
2820
 * creation of chardev, fsdev, net clients and device data types.
2821 2822 2823 2824 2825 2826 2827
 */
static bool object_create_delayed(const char *type)
{
    return !object_create_initial(type);
}


2828
static int object_create(void *opaque, QemuOpts *opts, Error **errp)
2829
{
P
Paolo Bonzini 已提交
2830 2831 2832 2833 2834 2835
    Error *err = NULL;
    char *type = NULL;
    char *id = NULL;
    void *dummy = NULL;
    OptsVisitor *ov;
    QDict *pdict;
2836
    bool (*type_predicate)(const char *) = opaque;
2837

P
Paolo Bonzini 已提交
2838 2839
    ov = opts_visitor_new(opts);
    pdict = qemu_opts_to_qdict(opts, NULL);
2840

P
Paolo Bonzini 已提交
2841 2842 2843
    visit_start_struct(opts_get_visitor(ov), &dummy, NULL, NULL, 0, &err);
    if (err) {
        goto out;
2844 2845
    }

P
Paolo Bonzini 已提交
2846 2847 2848 2849
    qdict_del(pdict, "qom-type");
    visit_type_str(opts_get_visitor(ov), &type, "qom-type", &err);
    if (err) {
        goto out;
2850
    }
2851 2852 2853
    if (!type_predicate(type)) {
        goto out;
    }
2854

P
Paolo Bonzini 已提交
2855 2856 2857
    qdict_del(pdict, "id");
    visit_type_str(opts_get_visitor(ov), &id, "id", &err);
    if (err) {
2858 2859 2860
        goto out;
    }

P
Paolo Bonzini 已提交
2861 2862
    object_add(type, id, pdict, opts_get_visitor(ov), &err);
    if (err) {
2863 2864
        goto out;
    }
P
Paolo Bonzini 已提交
2865 2866 2867 2868 2869
    visit_end_struct(opts_get_visitor(ov), &err);
    if (err) {
        qmp_object_del(id, NULL);
    }

2870
out:
P
Paolo Bonzini 已提交
2871 2872 2873 2874 2875 2876 2877
    opts_visitor_cleanup(ov);

    QDECREF(pdict);
    g_free(id);
    g_free(type);
    g_free(dummy);
    if (err) {
2878
        error_report_err(err);
2879 2880
        return -1;
    }
2881 2882 2883
    return 0;
}

2884 2885
static void set_memory_options(uint64_t *ram_slots, ram_addr_t *maxram_size,
                               MachineClass *mc)
2886 2887 2888 2889
{
    uint64_t sz;
    const char *mem_str;
    const char *maxmem_str, *slots_str;
2890
    const ram_addr_t default_ram_size = mc->default_ram_size;
2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927
    QemuOpts *opts = qemu_find_opts_singleton("memory");

    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 */
2928
    qemu_opt_set_number(opts, "size", ram_size, &error_abort);
2929 2930 2931 2932 2933 2934 2935 2936
    *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);
2937
        slots = qemu_opt_get_number(opts, "slots", 0);
2938
        if (sz < ram_size) {
2939 2940 2941 2942
            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);
2943
            exit(EXIT_FAILURE);
2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954
        } 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);
2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
            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);
    }
}

M
malc 已提交
2968
int main(int argc, char **argv, char **envp)
2969
{
T
ths 已提交
2970
    int i;
2971
    int snapshot, linux_boot;
B
bellard 已提交
2972
    const char *initrd_filename;
2973
    const char *kernel_filename, *kernel_cmdline;
2974 2975
    const char *boot_order = NULL;
    const char *boot_once = NULL;
2976
    DisplayState *ds;
2977
    int cyls, heads, secs, translation;
2978
    QemuOpts *hda_opts = NULL, *opts, *machine_opts, *icount_opts = NULL;
2979
    QemuOptsList *olist;
2980
    int optind;
2981
    const char *optarg;
B
bellard 已提交
2982
    const char *loadvm = NULL;
2983
    MachineClass *machine_class;
2984
    const char *cpu_model;
2985
    const char *vga_model = NULL;
2986 2987
    const char *qtest_chrdev = NULL;
    const char *qtest_log = NULL;
2988
    const char *pid_file = NULL;
A
aliguori 已提交
2989
    const char *incoming = NULL;
J
Jes Sorensen 已提交
2990
#ifdef CONFIG_VNC
2991
    int show_vnc_port = 0;
J
Jes Sorensen 已提交
2992
#endif
2993
    bool defconfig = true;
2994
    bool userconfig = true;
2995 2996
    const char *log_mask = NULL;
    const char *log_file = NULL;
2997
    const char *trace_events = NULL;
2998
    const char *trace_file = NULL;
2999
    ram_addr_t maxram_size;
3000
    uint64_t ram_slots = 0;
3001
    FILE *vmstate_dump_file = NULL;
3002
    Error *main_loop_err = NULL;
3003
    Error *err = NULL;
3004

3005 3006 3007
    qemu_init_cpu_loop();
    qemu_mutex_lock_iothread();

G
Gerd Hoffmann 已提交
3008
    atexit(qemu_run_exit_notifiers);
3009
    error_set_progname(argv[0]);
3010
    qemu_init_exec_dir(argv[0]);
3011

3012 3013
    module_call_init(MODULE_INIT_QOM);

3014
    qemu_add_opts(&qemu_drive_opts);
3015 3016 3017
    qemu_add_drive_opts(&qemu_legacy_drive_opts);
    qemu_add_drive_opts(&qemu_common_drive_opts);
    qemu_add_drive_opts(&qemu_drive_opts);
3018 3019 3020 3021 3022 3023 3024 3025 3026 3027
    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);
I
Igor Mammedov 已提交
3028
    qemu_add_opts(&qemu_mem_opts);
3029
    qemu_add_opts(&qemu_smp_opts);
3030 3031 3032 3033
    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);
3034
    qemu_add_opts(&qemu_tpmdev_opts);
3035
    qemu_add_opts(&qemu_realtime_opts);
S
Seiji Aguchi 已提交
3036
    qemu_add_opts(&qemu_msg_opts);
3037
    qemu_add_opts(&qemu_name_opts);
3038
    qemu_add_opts(&qemu_numa_opts);
3039
    qemu_add_opts(&qemu_icount_opts);
3040
    qemu_add_opts(&qemu_semihosting_config_opts);
3041
    qemu_add_opts(&qemu_fw_cfg_opts);
3042

3043 3044
    runstate_init();

3045
    if (qcrypto_init(&err) < 0) {
3046
        error_report("cannot initialize crypto: %s", error_get_pretty(err));
3047 3048
        exit(1);
    }
3049
    rtc_clock = QEMU_CLOCK_HOST;
J
Jan Kiszka 已提交
3050

B
Blue Swirl 已提交
3051
    QLIST_INIT (&vm_change_state_head);
3052
    os_setup_early_signal_handling();
3053

3054
    module_call_init(MODULE_INIT_MACHINE);
3055
    machine_class = find_default_machine();
3056
    cpu_model = NULL;
3057
    snapshot = 0;
3058 3059
    cyls = heads = secs = 0;
    translation = BIOS_ATA_TRANSLATION_AUTO;
3060

B
bellard 已提交
3061
    nb_nics = 0;
3062

3063 3064
    bdrv_init_with_whitelist();

3065
    autostart = 1;
3066

3067 3068 3069 3070 3071
    /* first pass of option parsing */
    optind = 1;
    while (optind < argc) {
        if (argv[optind][0] != '-') {
            /* disk image */
3072
            optind++;
3073 3074 3075 3076 3077 3078
        } else {
            const QEMUOption *popt;

            popt = lookup_opt(argc, argv, &optarg, &optind);
            switch (popt->index) {
            case QEMU_OPTION_nodefconfig:
3079
                defconfig = false;
3080
                break;
3081 3082 3083
            case QEMU_OPTION_nouserconfig:
                userconfig = false;
                break;
3084 3085 3086 3087 3088
            }
        }
    }

    if (defconfig) {
3089
        int ret;
3090
        ret = qemu_read_default_config_files(userconfig);
3091
        if (ret < 0) {
3092
            exit(1);
3093 3094 3095 3096
        }
    }

    /* second pass of option parsing */
3097
    optind = 1;
3098
    for(;;) {
3099
        if (optind >= argc)
3100
            break;
3101
        if (argv[optind][0] != '-') {
3102
            hda_opts = drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
3103 3104 3105
        } else {
            const QEMUOption *popt;

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

3430 3431 3432 3433 3434
                    graphic_width = w;
                    graphic_height = h;
                    graphic_depth = depth;
                }
                break;
T
ths 已提交
3435 3436 3437 3438 3439 3440 3441 3442
            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 已提交
3443
            case QEMU_OPTION_monitor:
G
Gerd Hoffmann 已提交
3444
                default_monitor = 0;
3445
                if (strncmp(optarg, "none", 4)) {
M
Max Reitz 已提交
3446
                    monitor_parse(optarg, "readline", false);
3447
                }
G
Gerd Hoffmann 已提交
3448 3449
                break;
            case QEMU_OPTION_qmp:
M
Max Reitz 已提交
3450 3451 3452 3453 3454
                monitor_parse(optarg, "control", false);
                default_monitor = 0;
                break;
            case QEMU_OPTION_qmp_pretty:
                monitor_parse(optarg, "control", true);
3455
                default_monitor = 0;
B
bellard 已提交
3456
                break;
G
Gerd Hoffmann 已提交
3457
            case QEMU_OPTION_mon:
3458 3459
                opts = qemu_opts_parse_noisily(qemu_find_opts("mon"), optarg,
                                               true);
G
Gerd Hoffmann 已提交
3460 3461 3462
                if (!opts) {
                    exit(1);
                }
3463
                default_monitor = 0;
G
Gerd Hoffmann 已提交
3464
                break;
3465
            case QEMU_OPTION_chardev:
3466 3467
                opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
                                               optarg, true);
3468 3469 3470 3471
                if (!opts) {
                    exit(1);
                }
                break;
3472
            case QEMU_OPTION_fsdev:
3473 3474
                olist = qemu_find_opts("fsdev");
                if (!olist) {
3475
                    error_report("fsdev support is disabled");
3476 3477
                    exit(1);
                }
3478
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3479 3480 3481 3482
                if (!opts) {
                    exit(1);
                }
                break;
3483
            case QEMU_OPTION_virtfs: {
3484 3485
                QemuOpts *fsdev;
                QemuOpts *device;
3486
                const char *writeout, *sock_fd, *socket;
3487

3488 3489
                olist = qemu_find_opts("virtfs");
                if (!olist) {
3490
                    error_report("virtfs support is disabled");
3491 3492
                    exit(1);
                }
3493
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3494 3495 3496 3497
                if (!opts) {
                    exit(1);
                }

3498
                if (qemu_opt_get(opts, "fsdriver") == NULL ||
3499
                    qemu_opt_get(opts, "mount_tag") == NULL) {
3500
                    error_report("Usage: -virtfs fsdriver,mount_tag=tag");
3501 3502
                    exit(1);
                }
3503
                fsdev = qemu_opts_create(qemu_find_opts("fsdev"),
3504 3505
                                         qemu_opt_get(opts, "mount_tag"),
                                         1, NULL);
3506
                if (!fsdev) {
3507 3508
                    error_report("duplicate fsdev id: %s",
                                 qemu_opt_get(opts, "mount_tag"));
3509 3510
                    exit(1);
                }
3511 3512 3513 3514

                writeout = qemu_opt_get(opts, "writeout");
                if (writeout) {
#ifdef CONFIG_SYNC_FILE_RANGE
3515
                    qemu_opt_set(fsdev, "writeout", writeout, &error_abort);
3516
#else
3517 3518
                    error_report("writeout=immediate not supported "
                                 "on this platform");
3519 3520 3521
                    exit(1);
#endif
                }
3522 3523 3524 3525
                qemu_opt_set(fsdev, "fsdriver",
                             qemu_opt_get(opts, "fsdriver"), &error_abort);
                qemu_opt_set(fsdev, "path", qemu_opt_get(opts, "path"),
                             &error_abort);
3526
                qemu_opt_set(fsdev, "security_model",
3527 3528
                             qemu_opt_get(opts, "security_model"),
                             &error_abort);
3529 3530
                socket = qemu_opt_get(opts, "socket");
                if (socket) {
3531
                    qemu_opt_set(fsdev, "socket", socket, &error_abort);
3532
                }
3533 3534
                sock_fd = qemu_opt_get(opts, "sock_fd");
                if (sock_fd) {
3535
                    qemu_opt_set(fsdev, "sock_fd", sock_fd, &error_abort);
3536
                }
3537

3538
                qemu_opt_set_bool(fsdev, "readonly",
3539 3540
                                  qemu_opt_get_bool(opts, "readonly", 0),
                                  &error_abort);
3541 3542
                device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                          &error_abort);
3543
                qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
3544
                qemu_opt_set(device, "fsdev",
3545
                             qemu_opt_get(opts, "mount_tag"), &error_abort);
3546
                qemu_opt_set(device, "mount_tag",
3547
                             qemu_opt_get(opts, "mount_tag"), &error_abort);
3548 3549
                break;
            }
3550 3551 3552 3553
            case QEMU_OPTION_virtfs_synth: {
                QemuOpts *fsdev;
                QemuOpts *device;

3554 3555
                fsdev = qemu_opts_create(qemu_find_opts("fsdev"), "v_synth",
                                         1, NULL);
3556
                if (!fsdev) {
3557
                    error_report("duplicate option: %s", "virtfs_synth");
3558 3559
                    exit(1);
                }
3560
                qemu_opt_set(fsdev, "fsdriver", "synth", &error_abort);
3561

3562 3563
                device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
                                          &error_abort);
3564 3565 3566
                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);
3567 3568
                break;
            }
B
bellard 已提交
3569
            case QEMU_OPTION_serial:
3570 3571
                add_device_config(DEV_SERIAL, optarg);
                default_serial = 0;
3572 3573 3574
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
B
bellard 已提交
3575
                break;
R
Richard W.M. Jones 已提交
3576
            case QEMU_OPTION_watchdog:
M
Markus Armbruster 已提交
3577
                if (watchdog) {
3578
                    error_report("only one watchdog option may be given");
M
Markus Armbruster 已提交
3579 3580 3581
                    return 1;
                }
                watchdog = optarg;
R
Richard W.M. Jones 已提交
3582 3583 3584
                break;
            case QEMU_OPTION_watchdog_action:
                if (select_watchdog_action(optarg) == -1) {
3585
                    error_report("unknown -watchdog-action parameter");
R
Richard W.M. Jones 已提交
3586 3587 3588
                    exit(1);
                }
                break;
3589
            case QEMU_OPTION_virtiocon:
G
Gerd Hoffmann 已提交
3590 3591
                add_device_config(DEV_VIRTCON, optarg);
                default_virtcon = 0;
3592 3593 3594
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
3595
                break;
3596
            case QEMU_OPTION_parallel:
G
Gerd Hoffmann 已提交
3597 3598
                add_device_config(DEV_PARALLEL, optarg);
                default_parallel = 0;
3599 3600 3601
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
3602
                break;
3603 3604 3605
            case QEMU_OPTION_debugcon:
                add_device_config(DEV_DEBUGCON, optarg);
                break;
3606 3607 3608
            case QEMU_OPTION_loadvm:
                loadvm = optarg;
                break;
B
bellard 已提交
3609 3610 3611
            case QEMU_OPTION_full_screen:
                full_screen = 1;
                break;
3612 3613 3614
            case QEMU_OPTION_no_frame:
                no_frame = 1;
                break;
T
ths 已提交
3615 3616 3617
            case QEMU_OPTION_alt_grab:
                alt_grab = 1;
                break;
3618 3619 3620
            case QEMU_OPTION_ctrl_grab:
                ctrl_grab = 1;
                break;
T
ths 已提交
3621 3622 3623
            case QEMU_OPTION_no_quit:
                no_quit = 1;
                break;
3624
            case QEMU_OPTION_sdl:
3625
#ifdef CONFIG_SDL
3626
                display_type = DT_SDL;
3627
                break;
3628
#else
3629
                error_report("SDL support is disabled");
3630
                exit(1);
T
ths 已提交
3631
#endif
B
bellard 已提交
3632
            case QEMU_OPTION_pidfile:
3633
                pid_file = optarg;
B
bellard 已提交
3634
                break;
3635 3636 3637
            case QEMU_OPTION_win2k_hack:
                win2k_install_hack = 1;
                break;
3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648
            case QEMU_OPTION_rtc_td_hack: {
                static GlobalProperty slew_lost_ticks[] = {
                    {
                        .driver   = "mc146818rtc",
                        .property = "lost_tick_policy",
                        .value    = "slew",
                    },
                    { /* end of list */ }
                };

                qdev_prop_register_global_list(slew_lost_ticks);
3649
                break;
3650
            }
3651
            case QEMU_OPTION_acpitable:
3652 3653
                opts = qemu_opts_parse_noisily(qemu_find_opts("acpi"),
                                               optarg, true);
3654 3655 3656
                if (!opts) {
                    exit(1);
                }
3657
                do_acpitable_option(opts);
3658
                break;
3659
            case QEMU_OPTION_smbios:
3660 3661
                opts = qemu_opts_parse_noisily(qemu_find_opts("smbios"),
                                               optarg, false);
3662 3663 3664
                if (!opts) {
                    exit(1);
                }
M
Markus Armbruster 已提交
3665
                do_smbios_option(opts);
3666
                break;
3667
            case QEMU_OPTION_fwcfg:
3668 3669
                opts = qemu_opts_parse_noisily(qemu_find_opts("fw_cfg"),
                                               optarg, true);
3670 3671 3672 3673
                if (opts == NULL) {
                    exit(1);
                }
                break;
A
aliguori 已提交
3674
            case QEMU_OPTION_enable_kvm:
3675
                olist = qemu_find_opts("machine");
3676
                qemu_opts_parse_noisily(olist, "accel=kvm", false);
3677
                break;
3678
            case QEMU_OPTION_M:
3679 3680
            case QEMU_OPTION_machine:
                olist = qemu_find_opts("machine");
3681
                opts = qemu_opts_parse_noisily(olist, optarg, true);
3682 3683 3684
                if (!opts) {
                    exit(1);
                }
A
aliguori 已提交
3685
                break;
J
Jan Kiszka 已提交
3686 3687
             case QEMU_OPTION_no_kvm:
                olist = qemu_find_opts("machine");
3688
                qemu_opts_parse_noisily(olist, "accel=tcg", false);
J
Jan Kiszka 已提交
3689
                break;
3690
            case QEMU_OPTION_no_kvm_pit: {
3691
                error_report("warning: ignoring deprecated option");
3692 3693
                break;
            }
3694 3695 3696 3697 3698 3699 3700 3701 3702 3703
            case QEMU_OPTION_no_kvm_pit_reinjection: {
                static GlobalProperty kvm_pit_lost_tick_policy[] = {
                    {
                        .driver   = "kvm-pit",
                        .property = "lost_tick_policy",
                        .value    = "discard",
                    },
                    { /* end of list */ }
                };

3704 3705
                error_report("warning: deprecated, replaced by "
                             "-global kvm-pit.lost_tick_policy=discard");
3706 3707 3708
                qdev_prop_register_global_list(kvm_pit_lost_tick_policy);
                break;
            }
B
bellard 已提交
3709
            case QEMU_OPTION_usb:
P
Peter Maydell 已提交
3710
                olist = qemu_find_opts("machine");
3711
                qemu_opts_parse_noisily(olist, "usb=on", false);
B
bellard 已提交
3712
                break;
B
bellard 已提交
3713
            case QEMU_OPTION_usbdevice:
P
Peter Maydell 已提交
3714
                olist = qemu_find_opts("machine");
3715
                qemu_opts_parse_noisily(olist, "usb=on", false);
3716 3717 3718
                add_device_config(DEV_USB, optarg);
                break;
            case QEMU_OPTION_device:
3719 3720
                if (!qemu_opts_parse_noisily(qemu_find_opts("device"),
                                             optarg, true)) {
G
Gerd Hoffmann 已提交
3721 3722
                    exit(1);
                }
B
bellard 已提交
3723
                break;
B
bellard 已提交
3724
            case QEMU_OPTION_smp:
3725 3726
                if (!qemu_opts_parse_noisily(qemu_find_opts("smp-opts"),
                                             optarg, true)) {
3727 3728
                    exit(1);
                }
B
bellard 已提交
3729
                break;
3730
            case QEMU_OPTION_vnc:
3731
            {
J
Jes Sorensen 已提交
3732
#ifdef CONFIG_VNC
3733 3734 3735 3736
                Error *local_err = NULL;

                if (vnc_parse(optarg, &local_err) == NULL) {
                    error_report_err(local_err);
3737 3738
                    exit(1);
                }
J
Jes Sorensen 已提交
3739
#else
3740
                error_report("VNC support is disabled");
J
Jes Sorensen 已提交
3741 3742 3743
                exit(1);
#endif
                break;
3744
            }
B
bellard 已提交
3745 3746 3747
            case QEMU_OPTION_no_acpi:
                acpi_enabled = 0;
                break;
A
aliguori 已提交
3748 3749 3750
            case QEMU_OPTION_no_hpet:
                no_hpet = 1;
                break;
3751 3752
            case QEMU_OPTION_balloon:
                if (balloon_parse(optarg) < 0) {
3753
                    error_report("unknown -balloon argument %s", optarg);
3754 3755
                    exit(1);
                }
3756
                break;
B
bellard 已提交
3757 3758 3759
            case QEMU_OPTION_no_reboot:
                no_reboot = 1;
                break;
A
aurel32 已提交
3760 3761 3762
            case QEMU_OPTION_no_shutdown:
                no_shutdown = 1;
                break;
3763 3764 3765
            case QEMU_OPTION_show_cursor:
                cursor_hide = 0;
                break;
3766 3767
            case QEMU_OPTION_uuid:
                if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
E
Eduardo Habkost 已提交
3768
                    error_report("failed to parse UUID string: wrong format");
3769 3770
                    exit(1);
                }
3771
                qemu_uuid_set = true;
3772
                break;
3773 3774
            case QEMU_OPTION_option_rom:
                if (nb_option_roms >= MAX_OPTION_ROMS) {
3775
                    error_report("too many option ROMs");
3776 3777
                    exit(1);
                }
3778 3779
                opts = qemu_opts_parse_noisily(qemu_find_opts("option-rom"),
                                               optarg, true);
3780 3781 3782
                if (!opts) {
                    exit(1);
                }
G
Gleb Natapov 已提交
3783 3784 3785 3786
                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) {
3787
                    error_report("Option ROM file is not specified");
G
Gleb Natapov 已提交
3788 3789
                    exit(1);
                }
3790 3791
                nb_option_roms++;
                break;
3792
            case QEMU_OPTION_semihosting:
3793 3794
                semihosting.enabled = true;
                semihosting.target = SEMIHOSTING_TARGET_AUTO;
3795 3796
                break;
            case QEMU_OPTION_semihosting_config:
3797
                semihosting.enabled = true;
3798 3799
                opts = qemu_opts_parse_noisily(qemu_find_opts("semihosting-config"),
                                               optarg, false);
3800
                if (opts != NULL) {
3801
                    semihosting.enabled = qemu_opt_get_bool(opts, "enable",
3802 3803 3804 3805
                                                            true);
                    const char *target = qemu_opt_get(opts, "target");
                    if (target != NULL) {
                        if (strcmp("native", target) == 0) {
3806
                            semihosting.target = SEMIHOSTING_TARGET_NATIVE;
3807
                        } else if (strcmp("gdb", target) == 0) {
3808
                            semihosting.target = SEMIHOSTING_TARGET_GDB;
3809
                        } else  if (strcmp("auto", target) == 0) {
3810
                            semihosting.target = SEMIHOSTING_TARGET_AUTO;
3811
                        } else {
3812
                            error_report("unsupported semihosting-config %s",
3813
                                         optarg);
3814 3815 3816
                            exit(1);
                        }
                    } else {
3817
                        semihosting.target = SEMIHOSTING_TARGET_AUTO;
3818
                    }
3819 3820 3821
                    /* Set semihosting argument count and vector */
                    qemu_opt_foreach(opts, add_semihosting_arg,
                                     &semihosting, NULL);
3822
                } else {
3823
                    error_report("unsupported semihosting-config %s", optarg);
3824 3825
                    exit(1);
                }
3826
                break;
3827
            case QEMU_OPTION_tdf:
3828
                error_report("warning: ignoring deprecated option");
3829
                break;
T
ths 已提交
3830
            case QEMU_OPTION_name:
3831 3832
                opts = qemu_opts_parse_noisily(qemu_find_opts("name"),
                                               optarg, true);
3833 3834 3835
                if (!opts) {
                    exit(1);
                }
T
ths 已提交
3836
                break;
B
blueswir1 已提交
3837 3838
            case QEMU_OPTION_prom_env:
                if (nb_prom_envs >= MAX_PROM_ENVS) {
3839
                    error_report("too many prom variables");
B
blueswir1 已提交
3840 3841 3842 3843 3844
                    exit(1);
                }
                prom_envs[nb_prom_envs] = optarg;
                nb_prom_envs++;
                break;
3845 3846
            case QEMU_OPTION_old_param:
                old_param = 1;
3847
                break;
3848
            case QEMU_OPTION_clock:
A
Alex Bligh 已提交
3849 3850 3851
                /* Clock options no longer exist.  Keep this option for
                 * backward compatibility.
                 */
3852
                break;
B
bellard 已提交
3853
            case QEMU_OPTION_startdate:
J
Jan Kiszka 已提交
3854 3855 3856
                configure_rtc_date_offset(optarg, 1);
                break;
            case QEMU_OPTION_rtc:
3857 3858
                opts = qemu_opts_parse_noisily(qemu_find_opts("rtc"), optarg,
                                               false);
J
Jan Kiszka 已提交
3859 3860
                if (!opts) {
                    exit(1);
B
bellard 已提交
3861
                }
J
Jan Kiszka 已提交
3862
                configure_rtc(opts);
B
bellard 已提交
3863
                break;
3864
            case QEMU_OPTION_tb_size:
3865 3866 3867 3868
                tcg_tb_size = strtol(optarg, NULL, 0);
                if (tcg_tb_size < 0) {
                    tcg_tb_size = 0;
                }
3869
                break;
P
pbrook 已提交
3870
            case QEMU_OPTION_icount:
3871 3872
                icount_opts = qemu_opts_parse_noisily(qemu_find_opts("icount"),
                                                      optarg, true);
3873 3874 3875
                if (!icount_opts) {
                    exit(1);
                }
P
pbrook 已提交
3876
                break;
A
aliguori 已提交
3877
            case QEMU_OPTION_incoming:
3878 3879 3880
                if (!incoming) {
                    runstate_set(RUN_STATE_INMIGRATE);
                }
A
aliguori 已提交
3881 3882
                incoming = optarg;
                break;
3883
            case QEMU_OPTION_nodefaults:
3884
                has_defaults = 0;
3885
                break;
3886
            case QEMU_OPTION_xen_domid:
3887 3888 3889 3890
                if (!(xen_available())) {
                    printf("Option %s not supported for this target\n", popt->name);
                    exit(1);
                }
3891 3892 3893
                xen_domid = atoi(optarg);
                break;
            case QEMU_OPTION_xen_create:
3894 3895 3896 3897
                if (!(xen_available())) {
                    printf("Option %s not supported for this target\n", popt->name);
                    exit(1);
                }
3898 3899 3900
                xen_mode = XEN_CREATE;
                break;
            case QEMU_OPTION_xen_attach:
3901 3902 3903 3904
                if (!(xen_available())) {
                    printf("Option %s not supported for this target\n", popt->name);
                    exit(1);
                }
3905 3906
                xen_mode = XEN_ATTACH;
                break;
3907
            case QEMU_OPTION_trace:
3908
            {
3909 3910
                opts = qemu_opts_parse_noisily(qemu_find_opts("trace"),
                                               optarg, false);
3911 3912
                if (!opts) {
                    exit(1);
3913
                }
3914
                trace_events = qemu_opt_get(opts, "events");
3915
                trace_file = qemu_opt_get(opts, "file");
3916
                break;
3917
            }
3918 3919
            case QEMU_OPTION_readconfig:
                {
3920 3921
                    int ret = qemu_read_config_file(optarg);
                    if (ret < 0) {
3922 3923
                        error_report("read config %s: %s", optarg,
                                     strerror(-ret));
3924 3925 3926 3927
                        exit(1);
                    }
                    break;
                }
G
Gerd Hoffmann 已提交
3928 3929 3930
            case QEMU_OPTION_spice:
                olist = qemu_find_opts("spice");
                if (!olist) {
3931
                    error_report("spice support is disabled");
G
Gerd Hoffmann 已提交
3932 3933
                    exit(1);
                }
3934
                opts = qemu_opts_parse_noisily(olist, optarg, false);
G
Gerd Hoffmann 已提交
3935 3936 3937
                if (!opts) {
                    exit(1);
                }
G
Gerd Hoffmann 已提交
3938
                display_remote++;
G
Gerd Hoffmann 已提交
3939
                break;
3940 3941 3942 3943 3944 3945 3946 3947
            case QEMU_OPTION_writeconfig:
                {
                    FILE *fp;
                    if (strcmp(optarg, "-") == 0) {
                        fp = stdout;
                    } else {
                        fp = fopen(optarg, "w");
                        if (fp == NULL) {
3948 3949
                            error_report("open %s: %s", optarg,
                                         strerror(errno));
3950 3951 3952 3953
                            exit(1);
                        }
                    }
                    qemu_config_write(fp);
3954 3955 3956
                    if (fp != stdout) {
                        fclose(fp);
                    }
3957 3958
                    break;
                }
A
Anthony Liguori 已提交
3959 3960 3961 3962 3963 3964
            case QEMU_OPTION_qtest:
                qtest_chrdev = optarg;
                break;
            case QEMU_OPTION_qtest_log:
                qtest_log = optarg;
                break;
3965
            case QEMU_OPTION_sandbox:
3966 3967
                opts = qemu_opts_parse_noisily(qemu_find_opts("sandbox"),
                                               optarg, true);
3968
                if (!opts) {
3969
                    exit(1);
3970 3971
                }
                break;
3972 3973
            case QEMU_OPTION_add_fd:
#ifndef _WIN32
3974 3975
                opts = qemu_opts_parse_noisily(qemu_find_opts("add-fd"),
                                               optarg, false);
3976
                if (!opts) {
3977
                    exit(1);
3978 3979 3980 3981 3982 3983 3984
                }
#else
                error_report("File descriptor passing is disabled on this "
                             "platform");
                exit(1);
#endif
                break;
3985
            case QEMU_OPTION_object:
3986 3987
                opts = qemu_opts_parse_noisily(qemu_find_opts("object"),
                                               optarg, true);
3988 3989 3990
                if (!opts) {
                    exit(1);
                }
3991
                break;
3992
            case QEMU_OPTION_realtime:
3993 3994
                opts = qemu_opts_parse_noisily(qemu_find_opts("realtime"),
                                               optarg, false);
3995 3996 3997
                if (!opts) {
                    exit(1);
                }
3998
                enable_mlock = qemu_opt_get_bool(opts, "mlock", true);
3999
                break;
S
Seiji Aguchi 已提交
4000
            case QEMU_OPTION_msg:
4001 4002
                opts = qemu_opts_parse_noisily(qemu_find_opts("msg"), optarg,
                                               false);
S
Seiji Aguchi 已提交
4003 4004 4005 4006 4007
                if (!opts) {
                    exit(1);
                }
                configure_msg(opts);
                break;
4008
            case QEMU_OPTION_dump_vmstate:
4009
                if (vmstate_dump_file) {
4010 4011
                    error_report("only one '-dump-vmstate' "
                                 "option may be given");
4012 4013
                    exit(1);
                }
4014 4015
                vmstate_dump_file = fopen(optarg, "w");
                if (vmstate_dump_file == NULL) {
4016
                    error_report("open %s: %s", optarg, strerror(errno));
4017 4018 4019
                    exit(1);
                }
                break;
4020 4021
            default:
                os_parse_cmd_args(popt->index, optarg);
4022
            }
4023 4024
        }
    }
4025

P
Pavel Dovgalyuk 已提交
4026 4027
    replay_configure(icount_opts);

4028 4029 4030 4031 4032 4033
    opts = qemu_get_machine_opts();
    optarg = qemu_opt_get(opts, "type");
    if (optarg) {
        machine_class = machine_parse(optarg);
    }

4034
    if (machine_class == NULL) {
4035 4036
        error_report("No machine specified, and there is no default");
        error_printf("Use -machine help to list supported machines\n");
4037 4038 4039 4040
        exit(1);
    }

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

4042
    loc_set_none();
4043

4044 4045
    os_daemonize();

4046
    if (qemu_init_main_loop(&main_loop_err)) {
4047
        error_report_err(main_loop_err);
P
Paolo Bonzini 已提交
4048 4049 4050
        exit(1);
    }

4051 4052
    if (qemu_opts_foreach(qemu_find_opts("sandbox"),
                          parse_sandbox, NULL, NULL)) {
4053 4054 4055
        exit(1);
    }

4056 4057
    if (qemu_opts_foreach(qemu_find_opts("name"),
                          parse_name, NULL, NULL)) {
4058 4059 4060
        exit(1);
    }

4061
#ifndef _WIN32
4062 4063
    if (qemu_opts_foreach(qemu_find_opts("add-fd"),
                          parse_add_fd, NULL, NULL)) {
4064 4065 4066
        exit(1);
    }

4067 4068
    if (qemu_opts_foreach(qemu_find_opts("add-fd"),
                          cleanup_add_fd, NULL, NULL)) {
4069 4070 4071 4072
        exit(1);
    }
#endif

4073 4074
    current_machine = MACHINE(object_new(object_class_get_name(
                          OBJECT_CLASS(machine_class))));
M
Marcel Apfelbaum 已提交
4075 4076 4077
    if (machine_help_func(qemu_get_machine_opts(), current_machine)) {
        exit(0);
    }
4078 4079
    object_property_add_child(object_get_root(), "machine",
                              OBJECT(current_machine), &error_abort);
4080
    cpu_exec_init_all();
4081

4082
    if (machine_class->hw_version) {
4083
        qemu_set_hw_version(machine_class->hw_version);
4084 4085
    }

4086 4087 4088 4089 4090 4091 4092
    /* Init CPU def lists, based on config
     * - Must be called after all the qemu_read_config_file() calls
     * - Must be called before list_cpus()
     * - Must be called before machine->init()
     */
    cpudef_init();

4093
    if (cpu_model && is_help_option(cpu_model)) {
E
Eduardo Habkost 已提交
4094
        list_cpus(stdout, &fprintf, cpu_model);
4095 4096 4097
        exit(0);
    }

4098
    /* Open the logfile at this point and set the log mask if necessary.
4099
     */
4100 4101 4102 4103
    if (log_file) {
        qemu_set_log_filename(log_file);
    }

4104
    if (log_mask) {
4105 4106 4107 4108 4109 4110 4111
        int mask;
        mask = qemu_str_to_log_mask(log_mask);
        if (!mask) {
            qemu_print_log_usage(stdout);
            exit(1);
        }
        qemu_set_log(mask);
4112
    }
4113

4114
    if (!is_daemonized()) {
L
Lluís Vilanova 已提交
4115
        if (!trace_init_backends(trace_events, trace_file)) {
4116 4117
            exit(1);
        }
4118
    }
4119

P
Paul Brook 已提交
4120 4121
    /* If no data_dir is specified then try to find it relative to the
       executable path.  */
4122
    if (data_dir_idx < ARRAY_SIZE(data_dir)) {
4123
        data_dir[data_dir_idx] = os_find_datadir();
4124 4125 4126
        if (data_dir[data_dir_idx] != NULL) {
            data_dir_idx++;
        }
P
Paul Brook 已提交
4127
    }
4128
    /* If all else fails use the install path specified when building. */
4129 4130
    if (data_dir_idx < ARRAY_SIZE(data_dir)) {
        data_dir[data_dir_idx++] = CONFIG_QEMU_DATADIR;
P
Paul Brook 已提交
4131 4132
    }

4133
    smp_parse(qemu_opts_find(qemu_find_opts("smp-opts"), NULL));
4134

4135
    machine_class->max_cpus = machine_class->max_cpus ?: 1; /* Default to UP */
A
Andrew Jones 已提交
4136
    if (max_cpus > machine_class->max_cpus) {
4137 4138 4139
        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);
4140 4141 4142
        exit(1);
    }

4143 4144 4145 4146
    /*
     * Get the default machine options from the machine if it is not already
     * specified either by the configuration file or by the command line.
     */
4147
    if (machine_class->default_machine_opts) {
4148
        qemu_opts_set_defaults(qemu_find_opts("machine"),
4149
                               machine_class->default_machine_opts, 0);
4150 4151
    }

4152 4153 4154 4155
    qemu_opts_foreach(qemu_find_opts("device"),
                      default_driver_check, NULL, NULL);
    qemu_opts_foreach(qemu_find_opts("global"),
                      default_driver_check, NULL, NULL);
4156

4157 4158 4159
    if (!vga_model && !default_vga) {
        vga_interface_type = VGA_DEVICE;
    }
4160
    if (!has_defaults || machine_class->no_serial) {
4161 4162
        default_serial = 0;
    }
4163
    if (!has_defaults || machine_class->no_parallel) {
4164 4165
        default_parallel = 0;
    }
4166
    if (!has_defaults || !machine_class->use_virtcon) {
4167 4168
        default_virtcon = 0;
    }
4169
    if (!has_defaults || !machine_class->use_sclp) {
4170 4171
        default_sclp = 0;
    }
4172
    if (!has_defaults || machine_class->no_floppy) {
G
Gerd Hoffmann 已提交
4173 4174
        default_floppy = 0;
    }
4175
    if (!has_defaults || machine_class->no_cdrom) {
G
Gerd Hoffmann 已提交
4176 4177
        default_cdrom = 0;
    }
4178
    if (!has_defaults || machine_class->no_sdcard) {
G
Gerd Hoffmann 已提交
4179 4180
        default_sdcard = 0;
    }
4181 4182 4183 4184 4185
    if (!has_defaults) {
        default_monitor = 0;
        default_net = 0;
        default_vga = 0;
    }
4186

4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199
    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.
         */
        if (display_type == DT_NOGRAPHIC
            && (default_parallel || default_serial
                || default_monitor || default_virtcon)) {
E
Eduardo Habkost 已提交
4200
            error_report("-nographic cannot be used with -daemonize");
4201 4202 4203 4204
            exit(1);
        }
#ifdef CONFIG_CURSES
        if (display_type == DT_CURSES) {
E
Eduardo Habkost 已提交
4205
            error_report("curses display cannot be used with -daemonize");
4206 4207 4208 4209 4210
            exit(1);
        }
#endif
    }

4211
    if (display_type == DT_NOGRAPHIC) {
G
Gerd Hoffmann 已提交
4212 4213
        if (default_parallel)
            add_device_config(DEV_PARALLEL, "null");
G
Gerd Hoffmann 已提交
4214 4215
        if (default_serial && default_monitor) {
            add_device_config(DEV_SERIAL, "mon:stdio");
4216 4217
        } else if (default_virtcon && default_monitor) {
            add_device_config(DEV_VIRTCON, "mon:stdio");
4218 4219
        } else if (default_sclp && default_monitor) {
            add_device_config(DEV_SCLP, "mon:stdio");
G
Gerd Hoffmann 已提交
4220 4221 4222
        } else {
            if (default_serial)
                add_device_config(DEV_SERIAL, "stdio");
4223 4224
            if (default_virtcon)
                add_device_config(DEV_VIRTCON, "stdio");
4225 4226 4227
            if (default_sclp) {
                add_device_config(DEV_SCLP, "stdio");
            }
G
Gerd Hoffmann 已提交
4228
            if (default_monitor)
M
Max Reitz 已提交
4229
                monitor_parse("stdio", "readline", false);
G
Gerd Hoffmann 已提交
4230
        }
4231 4232 4233
    } else {
        if (default_serial)
            add_device_config(DEV_SERIAL, "vc:80Cx24C");
G
Gerd Hoffmann 已提交
4234 4235
        if (default_parallel)
            add_device_config(DEV_PARALLEL, "vc:80Cx24C");
G
Gerd Hoffmann 已提交
4236
        if (default_monitor)
M
Max Reitz 已提交
4237
            monitor_parse("vc:80Cx24C", "readline", false);
4238 4239
        if (default_virtcon)
            add_device_config(DEV_VIRTCON, "vc:80Cx24C");
4240 4241 4242
        if (default_sclp) {
            add_device_config(DEV_SCLP, "vc:80Cx24C");
        }
4243 4244
    }

G
Gerd Hoffmann 已提交
4245 4246 4247 4248 4249
#if defined(CONFIG_VNC)
    if (!QTAILQ_EMPTY(&(qemu_find_opts("vnc")->head))) {
        display_remote++;
    }
#endif
A
Anthony Liguori 已提交
4250 4251 4252 4253 4254 4255
    if (display_type == DT_DEFAULT && !display_remote) {
#if defined(CONFIG_GTK)
        display_type = DT_GTK;
#elif defined(CONFIG_SDL) || defined(CONFIG_COCOA)
        display_type = DT_SDL;
#elif defined(CONFIG_VNC)
4256
        vnc_parse("localhost:0,to=99,id=default", &error_abort);
A
Anthony Liguori 已提交
4257 4258 4259 4260 4261 4262
        show_vnc_port = 1;
#else
        display_type = DT_NONE;
#endif
    }

4263
    if ((no_frame || alt_grab || ctrl_grab) && display_type != DT_SDL) {
4264 4265
        error_report("-no-frame, -alt-grab and -ctrl-grab are only valid "
                     "for SDL, ignoring option");
4266 4267
    }
    if (no_quit && (display_type != DT_GTK && display_type != DT_SDL)) {
4268 4269
        error_report("-no-quit is only valid for GTK and SDL, "
                     "ignoring option");
4270 4271
    }

A
Anthony Liguori 已提交
4272 4273
#if defined(CONFIG_GTK)
    if (display_type == DT_GTK) {
4274
        early_gtk_display_init(request_opengl);
A
Anthony Liguori 已提交
4275 4276
    }
#endif
4277 4278 4279 4280 4281 4282 4283
#if defined(CONFIG_SDL)
    if (display_type == DT_SDL) {
        sdl_display_early_init(request_opengl);
    }
#endif
    if (request_opengl == 1 && display_opengl == 0) {
#if defined(CONFIG_OPENGL)
4284
        error_report("OpenGL is not supported by the display");
4285
#else
4286
        error_report("OpenGL support is disabled");
4287 4288 4289
#endif
        exit(1);
    }
A
Anthony Liguori 已提交
4290

4291
    page_size_init();
T
TeLeMan 已提交
4292 4293
    socket_init();

4294 4295 4296
    if (qemu_opts_foreach(qemu_find_opts("object"),
                          object_create,
                          object_create_initial, NULL)) {
4297
        exit(1);
4298 4299
    }

4300 4301 4302 4303 4304
    if (qemu_opts_foreach(qemu_find_opts("chardev"),
                          chardev_init_func, NULL, NULL)) {
        exit(1);
    }

4305
#ifdef CONFIG_VIRTFS
4306 4307
    if (qemu_opts_foreach(qemu_find_opts("fsdev"),
                          fsdev_init_func, NULL, NULL)) {
4308 4309 4310
        exit(1);
    }
#endif
4311

4312
    if (pid_file && qemu_create_pidfile(pid_file) != 0) {
4313
        error_report("could not acquire pid file: %s", strerror(errno));
4314 4315 4316
        exit(1);
    }

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

4322
    machine_opts = qemu_get_machine_opts();
4323 4324
    if (qemu_opt_foreach(machine_opts, machine_set_property, current_machine,
                         NULL)) {
4325 4326 4327 4328
        object_unref(OBJECT(current_machine));
        exit(1);
    }

4329
    configure_accelerator(current_machine);
M
Marcelo Tosatti 已提交
4330

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

4335 4336 4337 4338
    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");
G
Gerd Hoffmann 已提交
4339
    bios_name = qemu_opt_get(machine_opts, "firmware");
4340

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

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

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

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

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

4366
    linux_boot = (kernel_filename != NULL);
B
balrog 已提交
4367

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

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

4378
    if (!linux_boot && qemu_opt_get(machine_opts, "dtb")) {
4379
        error_report("-dtb only allowed with -kernel option");
G
Grant Likely 已提交
4380 4381 4382
        exit(1);
    }

4383 4384 4385 4386 4387
    if (semihosting_enabled() && !semihosting_get_argc() && kernel_filename) {
        /* fall back to the -kernel/-append */
        semihosting_arg_fallback(kernel_filename, kernel_cmdline);
    }

4388
    os_set_line_buffering();
4389

A
Alon Levy 已提交
4390 4391 4392 4393 4394
#ifdef CONFIG_SPICE
    /* spice needs the timers to be initialized by this point */
    qemu_spice_init();
#endif

4395
    cpu_ticks_init();
4396 4397
    if (icount_opts) {
        if (kvm_enabled() || xen_enabled()) {
4398
            error_report("-icount is not allowed with kvm or xen");
4399 4400 4401 4402
            exit(1);
        }
        configure_icount(icount_opts, &error_abort);
        qemu_opts_del(icount_opts);
4403
    }
4404

4405 4406 4407
    /* clean up network at qemu process termination */
    atexit(&net_cleanup);

4408 4409
    if (net_init_clients() < 0) {
        exit(1);
B
bellard 已提交
4410
    }
B
bellard 已提交
4411

4412 4413 4414 4415 4416 4417
    if (qemu_opts_foreach(qemu_find_opts("object"),
                          object_create,
                          object_create_delayed, NULL)) {
        exit(1);
    }

4418 4419 4420 4421 4422 4423
#ifdef CONFIG_TPM
    if (tpm_init() < 0) {
        exit(1);
    }
#endif

4424
    /* init the bluetooth world */
4425 4426
    if (foreach_device_config(DEV_BT, bt_parse))
        exit(1);
4427

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

L
lirans@il.ibm.com 已提交
4436
    blk_mig_init();
4437
    ram_mig_init();
L
lirans@il.ibm.com 已提交
4438

4439 4440 4441 4442 4443 4444 4445
    /* 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);
    }

T
ths 已提交
4446
    /* open the virtual block devices */
P
Pavel Dovgalyuk 已提交
4447 4448 4449 4450
    if (snapshot || replay_mode != REPLAY_MODE_NONE) {
        qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot,
                          NULL, NULL);
    }
4451
    if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func,
4452
                          &machine_class->block_default_type, NULL)) {
G
Gerd Hoffmann 已提交
4453
        exit(1);
4454
    }
4455

4456
    default_drive(default_cdrom, snapshot, machine_class->block_default_type, 2,
4457 4458 4459
                  CDROM_OPTS);
    default_drive(default_floppy, snapshot, IF_FLOPPY, 0, FD_OPTS);
    default_drive(default_sdcard, snapshot, IF_SD, 0, SD_OPTS);
4460

4461
    parse_numa_opts(machine_class);
4462

4463 4464
    if (qemu_opts_foreach(qemu_find_opts("mon"),
                          mon_init_func, NULL, NULL)) {
4465 4466 4467
        exit(1);
    }

4468 4469
    if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
        exit(1);
G
Gerd Hoffmann 已提交
4470 4471
    if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
        exit(1);
G
Gerd Hoffmann 已提交
4472 4473
    if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
        exit(1);
4474 4475 4476
    if (foreach_device_config(DEV_SCLP, sclp_parse) < 0) {
        exit(1);
    }
4477 4478
    if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
        exit(1);
4479

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

M
Markus Armbruster 已提交
4494 4495 4496 4497 4498 4499
    if (watchdog) {
        i = select_watchdog(watchdog);
        if (i > 0)
            exit (i == 1 ? 1 : 0);
    }

4500 4501
    if (machine_class->compat_props) {
        qdev_prop_register_global_list(machine_class->compat_props);
4502
    }
4503 4504
    qemu_add_globals();

P
Pavel Dovgalyuk 已提交
4505 4506 4507 4508
    /* 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);
4509 4510
    qdev_machine_init();

4511
    current_machine->ram_size = ram_size;
4512 4513
    current_machine->maxram_size = maxram_size;
    current_machine->ram_slots = ram_slots;
4514 4515 4516 4517
    current_machine->boot_order = boot_order;
    current_machine->cpu_model = cpu_model;

    machine_class->init(current_machine);
4518

4519 4520
    realtime_init();

4521 4522
    audio_init();

4523
    cpu_synchronize_all_post_init();
4524

4525
    numa_post_machine_init();
4526

4527 4528 4529 4530 4531
    if (qemu_opts_foreach(qemu_find_opts("fw_cfg"),
                          parse_fw_cfg, fw_cfg_find(), NULL) != 0) {
        exit(1);
    }

4532
    /* init USB devices */
4533
    if (usb_enabled()) {
M
Markus Armbruster 已提交
4534 4535
        if (foreach_device_config(DEV_USB, usb_parse) < 0)
            exit(1);
4536 4537
    }

4538 4539 4540
    /* Check if IGD GFX passthrough. */
    igd_gfx_passthru();

4541
    /* init generic devices */
4542 4543
    if (qemu_opts_foreach(qemu_find_opts("device"),
                          device_init_func, NULL, NULL)) {
4544
        exit(1);
4545
    }
4546

J
John Snow 已提交
4547 4548 4549
    /* Did we create any drives that we failed to create a device for? */
    drive_check_orphaned();

4550 4551
    net_check_clients();

4552 4553 4554 4555 4556 4557 4558 4559 4560 4561
    if (boot_once) {
        Error *local_err = NULL;
        qemu_boot_set(boot_once, &local_err);
        if (local_err) {
            error_report("%s", error_get_pretty(local_err));
            exit(1);
        }
        qemu_register_reset(restore_boot_order, g_strdup(boot_order));
    }

4562
    ds = init_displaystate();
4563

4564
    /* init local displays */
4565 4566
    switch (display_type) {
    case DT_NOGRAPHIC:
4567
        (void)ds;	/* avoid warning if no display is configured */
4568
        break;
B
balrog 已提交
4569
#if defined(CONFIG_CURSES)
4570
    case DT_CURSES:
4571
        curses_display_init(ds, full_screen);
4572
        break;
B
balrog 已提交
4573
#endif
4574
#if defined(CONFIG_SDL)
4575 4576 4577
    case DT_SDL:
        sdl_display_init(ds, full_screen, no_frame);
        break;
4578
#elif defined(CONFIG_COCOA)
4579 4580 4581
    case DT_SDL:
        cocoa_display_init(ds, full_screen);
        break;
A
Anthony Liguori 已提交
4582 4583 4584
#endif
#if defined(CONFIG_GTK)
    case DT_GTK:
4585
        gtk_display_init(ds, full_screen, grab_on_hover);
A
Anthony Liguori 已提交
4586
        break;
4587
#endif
4588 4589 4590 4591
    default:
        break;
    }

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

J
Jes Sorensen 已提交
4595
#ifdef CONFIG_VNC
4596
    /* init remote displays */
4597 4598
    qemu_opts_foreach(qemu_find_opts("vnc"),
                      vnc_init_func, NULL, NULL);
4599
    if (show_vnc_port) {
4600
        char *ret = vnc_display_local_addr("default");
E
Eduardo Habkost 已提交
4601
        printf("VNC server running on '%s'\n", ret);
4602
        g_free(ret);
4603
    }
J
Jes Sorensen 已提交
4604
#endif
G
Gerd Hoffmann 已提交
4605
#ifdef CONFIG_SPICE
G
Gerd Hoffmann 已提交
4606 4607
    if (using_spice) {
        qemu_spice_display_init();
G
Gerd Hoffmann 已提交
4608 4609
    }
#endif
4610

4611
    if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) {
4612
        exit(1);
4613 4614
    }

4615 4616
    qdev_machine_creation_done();

4617 4618 4619
    /* 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());
4620 4621
    qemu_run_machine_init_done_notifiers();

4622
    if (rom_check_and_register_reset() != 0) {
4623
        error_report("rom check and register reset failed");
4624 4625
        exit(1);
    }
4626

4627 4628
    replay_start();

P
Pavel Dovgalyuk 已提交
4629 4630 4631 4632
    /* 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);
J
Jan Kiszka 已提交
4633
    qemu_system_reset(VMRESET_SILENT);
4634
    register_global_state();
4635
    if (loadvm) {
4636
        if (load_vmstate(loadvm) < 0) {
4637 4638 4639
            autostart = 0;
        }
    }
B
bellard 已提交
4640

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

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

4661
    os_setup_post();
T
ths 已提交
4662

4663
    if (is_daemonized()) {
L
Lluís Vilanova 已提交
4664
        if (!trace_init_backends(trace_events, trace_file)) {
4665 4666 4667 4668
            exit(1);
        }
    }

4669
    main_loop();
4670 4671
    replay_disable_events();

P
Paolo Bonzini 已提交
4672 4673
    bdrv_close_all();
    pause_all_vcpus();
W
wayne 已提交
4674
    res_free();
4675 4676 4677
#ifdef CONFIG_TPM
    tpm_cleanup();
#endif
T
ths 已提交
4678

4679 4680
    return 0;
}