* THE SOFTWARE.
*/
#include "qemu/osdep.h"
-
+#include "qemu-version.h"
+#include "qemu/cutils.h"
+#include "qemu/help_option.h"
#ifdef CONFIG_SECCOMP
#include "sysemu/seccomp.h"
#define main qemu_main
#endif /* CONFIG_COCOA */
-#include <glib.h>
#include "qemu/error-report.h"
#include "qemu/sockets.h"
#include "net/slirp.h"
#include "monitor/monitor.h"
#include "ui/console.h"
+#include "ui/input.h"
#include "sysemu/sysemu.h"
#include "sysemu/numa.h"
#include "exec/gdbstub.h"
#include "qemu/timer.h"
#include "sysemu/char.h"
#include "qemu/bitmap.h"
+#include "qemu/log.h"
#include "sysemu/blockdev.h"
#include "hw/block/block.h"
#include "migration/block.h"
#include "sysemu/dma.h"
#include "audio/audio.h"
#include "migration/migration.h"
+#include "sysemu/cpus.h"
#include "sysemu/kvm.h"
#include "qapi/qmp/qjson.h"
#include "qemu/option.h"
static int data_dir_idx;
const char *bios_name = NULL;
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
-DisplayType display_type = DT_DEFAULT;
int request_opengl = -1;
int display_opengl;
-static int display_remote;
const char* keyboard_layout = NULL;
ram_addr_t ram_size;
const char *mem_path = NULL;
static int full_screen = 0;
static int no_frame = 0;
int no_quit = 0;
-#ifdef CONFIG_GTK
static bool grab_on_hover;
-#endif
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
int win2k_install_hack = 0;
int singlestep = 0;
int smp_cpus = 1;
-int max_cpus = 0;
+int max_cpus = 1;
int smp_cores = 1;
int smp_threads = 1;
int acpi_enabled = 1;
static int default_cdrom = 1;
static int default_sdcard = 1;
static int default_vga = 1;
+static int default_net = 1;
static struct {
const char *driver;
{
assert(new_state < RUN_STATE__MAX);
+ if (current_run_state == new_state) {
+ return;
+ }
+
if (!runstate_valid_transitions[current_run_state][new_state]) {
error_report("invalid runstate transition: '%s' -> '%s'",
RunState_lookup[current_run_state],
value = qemu_opt_get(opts, "driftfix");
if (value) {
if (!strcmp(value, "slew")) {
- static GlobalProperty slew_lost_ticks[] = {
- {
- .driver = "mc146818rtc",
- .property = "lost_tick_policy",
- .value = "slew",
- },
- { /* end of list */ }
+ static GlobalProperty slew_lost_ticks = {
+ .driver = "mc146818rtc",
+ .property = "lost_tick_policy",
+ .value = "slew",
};
- qdev_prop_register_global_list(slew_lost_ticks);
+ qdev_prop_register_global(&slew_lost_ticks);
} else if (!strcmp(value, "none")) {
/* discard is default */
} else {
return has_defaults;
}
-bool usb_enabled(void)
-{
- return machine_usb(current_machine);
-}
-
#ifndef _WIN32
static int parse_add_fd(void *opaque, QemuOpts *opts, Error **errp)
{
static void smp_parse(QemuOpts *opts)
{
if (opts) {
-
unsigned cpus = qemu_opt_get_number(opts, "cpus", 0);
unsigned sockets = qemu_opt_get_number(opts, "sockets", 0);
unsigned cores = qemu_opt_get_number(opts, "cores", 0);
}
max_cpus = qemu_opt_get_number(opts, "maxcpus", cpus);
+
+ if (max_cpus > MAX_CPUMASK_BITS) {
+ error_report("unsupported number of maxcpus");
+ exit(1);
+ }
+
+ if (max_cpus < cpus) {
+ error_report("maxcpus must be equal to or greater than smp");
+ exit(1);
+ }
+
if (sockets * cores * threads > max_cpus) {
error_report("cpu topology: "
"sockets (%u) * cores (%u) * threads (%u) > "
}
smp_cpus = cpus;
- smp_cores = cores > 0 ? cores : 1;
- smp_threads = threads > 0 ? threads : 1;
-
- }
-
- if (max_cpus == 0) {
- max_cpus = smp_cpus;
- }
-
- if (max_cpus > MAX_CPUMASK_BITS) {
- error_report("unsupported number of maxcpus");
- exit(1);
- }
- if (max_cpus < smp_cpus) {
- error_report("maxcpus must be equal to or greater than smp");
- exit(1);
+ smp_cores = cores;
+ smp_threads = threads;
}
- if (smp_cpus > 1 || smp_cores > 1 || smp_threads > 1) {
+ if (smp_cpus > 1) {
Error *blocker = NULL;
error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED, "smp");
replay_add_blocker(blocker);
const char *p;
#endif
- if (!usb_enabled()) {
+ if (!machine_usb(current_machine)) {
return -1;
}
return -1;
}
- if (!usb_enabled()) {
+ if (!machine_usb(current_machine)) {
return -1;
}
mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;
+ cpu_synchronize_all_states();
+
if (mc && mc->reset) {
mc->reset();
} else {
}
if (qemu_reset_requested()) {
pause_all_vcpus();
- cpu_synchronize_all_states();
qemu_system_reset(VMRESET_REPORT);
resume_all_vcpus();
if (!runstate_check(RUN_STATE_RUNNING) &&
}
if (qemu_wakeup_requested()) {
pause_all_vcpus();
- cpu_synchronize_all_states();
qemu_system_reset(VMRESET_SILENT);
notifier_list_notify(&wakeup_notifiers, &wakeup_reason);
wakeup_reason = QEMU_WAKEUP_REASON_NONE;
{ NULL },
};
-static bool vga_available(void)
-{
- return object_class_by_name("VGA") || object_class_by_name("isa-vga");
-}
-
-static bool cirrus_vga_available(void)
-{
- return object_class_by_name("cirrus-vga")
- || object_class_by_name("isa-cirrus-vga");
-}
-
-static bool vmware_vga_available(void)
-{
- return object_class_by_name("vmware-svga");
-}
-
-static bool qxl_vga_available(void)
-{
- return object_class_by_name("qxl-vga");
-}
+typedef struct VGAInterfaceInfo {
+ const char *opt_name; /* option name */
+ const char *name; /* human-readable name */
+ /* Class names indicating that support is available.
+ * If no class is specified, the interface is always available */
+ const char *class_names[2];
+} VGAInterfaceInfo;
+
+static VGAInterfaceInfo vga_interfaces[VGA_TYPE_MAX] = {
+ [VGA_NONE] = {
+ .opt_name = "none",
+ },
+ [VGA_STD] = {
+ .opt_name = "std",
+ .name = "standard VGA",
+ .class_names = { "VGA", "isa-vga" },
+ },
+ [VGA_CIRRUS] = {
+ .opt_name = "cirrus",
+ .name = "Cirrus VGA",
+ .class_names = { "cirrus-vga", "isa-cirrus-vga" },
+ },
+ [VGA_VMWARE] = {
+ .opt_name = "vmware",
+ .name = "VMWare SVGA",
+ .class_names = { "vmware-svga" },
+ },
+ [VGA_VIRTIO] = {
+ .opt_name = "virtio",
+ .name = "Virtio VGA",
+ .class_names = { "virtio-vga" },
+ },
+ [VGA_QXL] = {
+ .opt_name = "qxl",
+ .name = "QXL VGA",
+ .class_names = { "qxl-vga" },
+ },
+ [VGA_TCX] = {
+ .opt_name = "tcx",
+ .name = "TCX framebuffer",
+ .class_names = { "SUNW,tcx" },
+ },
+ [VGA_CG3] = {
+ .opt_name = "cg3",
+ .name = "CG3 framebuffer",
+ .class_names = { "cgthree" },
+ },
+ [VGA_XENFB] = {
+ .opt_name = "xenfb",
+ },
+};
-static bool tcx_vga_available(void)
+static bool vga_interface_available(VGAInterfaceType t)
{
- return object_class_by_name("SUNW,tcx");
-}
+ VGAInterfaceInfo *ti = &vga_interfaces[t];
-static bool cg3_vga_available(void)
-{
- return object_class_by_name("cgthree");
+ assert(t < VGA_TYPE_MAX);
+ return !ti->class_names[0] ||
+ object_class_by_name(ti->class_names[0]) ||
+ object_class_by_name(ti->class_names[1]);
}
-static bool virtio_vga_available(void)
-{
- return object_class_by_name("virtio-vga");
-}
-
-static void select_vgahw (const char *p)
+static void select_vgahw(const char *p)
{
const char *opts;
+ int t;
assert(vga_interface_type == VGA_NONE);
- if (strstart(p, "std", &opts)) {
- if (vga_available()) {
- vga_interface_type = VGA_STD;
- } else {
- error_report("standard VGA not available");
- exit(0);
- }
- } else if (strstart(p, "cirrus", &opts)) {
- if (cirrus_vga_available()) {
- vga_interface_type = VGA_CIRRUS;
- } else {
- error_report("Cirrus VGA not available");
- exit(0);
- }
- } else if (strstart(p, "vmware", &opts)) {
- if (vmware_vga_available()) {
- vga_interface_type = VGA_VMWARE;
- } else {
- error_report("VMWare SVGA not available");
- exit(0);
- }
- } else if (strstart(p, "virtio", &opts)) {
- if (virtio_vga_available()) {
- vga_interface_type = VGA_VIRTIO;
- } else {
- error_report("Virtio VGA not available");
- exit(0);
- }
- } else if (strstart(p, "xenfb", &opts)) {
- vga_interface_type = VGA_XENFB;
- } else if (strstart(p, "qxl", &opts)) {
- if (qxl_vga_available()) {
- vga_interface_type = VGA_QXL;
- } else {
- error_report("QXL VGA not available");
- exit(0);
- }
- } else if (strstart(p, "tcx", &opts)) {
- if (tcx_vga_available()) {
- vga_interface_type = VGA_TCX;
- } else {
- error_report("TCX framebuffer not available");
- exit(0);
- }
- } else if (strstart(p, "cg3", &opts)) {
- if (cg3_vga_available()) {
- vga_interface_type = VGA_CG3;
- } else {
- error_report("CG3 framebuffer not available");
- exit(0);
+ for (t = 0; t < VGA_TYPE_MAX; t++) {
+ VGAInterfaceInfo *ti = &vga_interfaces[t];
+ if (ti->opt_name && strstart(p, ti->opt_name, &opts)) {
+ if (!vga_interface_available(t)) {
+ error_report("%s not available", ti->name);
+ exit(1);
+ }
+ vga_interface_type = t;
+ break;
}
- } else if (!strstart(p, "none", &opts)) {
+ }
+ if (t == VGA_TYPE_MAX) {
invalid_vga:
error_report("unknown vga type: %s", p);
exit(1);
}
}
+typedef enum DisplayType {
+ DT_DEFAULT,
+ DT_CURSES,
+ DT_SDL,
+ DT_COCOA,
+ DT_GTK,
+ DT_NONE,
+} DisplayType;
+
static DisplayType select_display(const char *p)
{
const char *opts;
exit(1);
#endif
} else if (strstart(p, "vnc", &opts)) {
-#ifdef CONFIG_VNC
if (*opts == '=') {
- Error *err = NULL;
- if (vnc_parse(opts + 1, &err) == NULL) {
- error_report_err(err);
- exit(1);
- }
+ vnc_parse(opts + 1, &error_fatal);
} else {
error_report("VNC requires a display argument vnc=<display>");
exit(1);
}
-#else
- error_report("VNC support is disabled");
- exit(1);
-#endif
} else if (strstart(p, "curses", &opts)) {
#ifdef CONFIG_CURSES
display = DT_CURSES;
gchar *buf;
size_t size;
const char *name, *file, *str;
+ FWCfgState *fw_cfg = (FWCfgState *) opaque;
- if (opaque == NULL) {
+ if (fw_cfg == NULL) {
error_report("fw_cfg device not available");
return -1;
}
return -1;
}
}
- fw_cfg_add_file((FWCfgState *)opaque, name, buf, size);
+ /* For legacy, keep user files in a specific global order. */
+ fw_cfg_set_order_override(fw_cfg, FW_CFG_ORDER_OVERRIDE_USER);
+ fw_cfg_add_file(fw_cfg, name, buf, size);
+ fw_cfg_reset_order_override(fw_cfg);
return 0;
}
#ifdef CONFIG_VIRTFS
static int fsdev_init_func(void *opaque, QemuOpts *opts, Error **errp)
{
- int ret;
- ret = qemu_fsdev_add(opts);
-
- return ret;
+ return qemu_fsdev_add(opts);
}
#endif
static void monitor_parse(const char *optarg, const char *mode, bool pretty)
{
static int monitor_device_index = 0;
- Error *local_err = NULL;
QemuOpts *opts;
const char *p;
char label[32];
}
}
- opts = qemu_opts_create(qemu_find_opts("mon"), label, 1, &local_err);
- if (!opts) {
- error_report_err(local_err);
- exit(1);
- }
+ opts = qemu_opts_create(qemu_find_opts("mon"), label, 1, &error_fatal);
qemu_opt_set(opts, "mode", mode, &error_abort);
qemu_opt_set(opts, "chardev", label, &error_abort);
qemu_opt_set_bool(opts, "pretty", pretty, &error_abort);
* they depend on netdevs already existing
*/
if (g_str_equal(type, "filter-buffer") ||
- g_str_equal(type, "filter-dump")) {
+ g_str_equal(type, "filter-dump") ||
+ g_str_equal(type, "filter-mirror") ||
+ g_str_equal(type, "filter-redirector")) {
return false;
}
const char *qtest_log = NULL;
const char *pid_file = NULL;
const char *incoming = NULL;
-#ifdef CONFIG_VNC
int show_vnc_port = 0;
-#endif
bool defconfig = true;
bool userconfig = true;
+ bool nographic = false;
+ DisplayType display_type = DT_DEFAULT;
+ int display_remote = 0;
const char *log_mask = NULL;
const char *log_file = NULL;
char *trace_file = NULL;
FILE *vmstate_dump_file = NULL;
Error *main_loop_err = NULL;
Error *err = NULL;
+ bool list_data_dirs = false;
qemu_init_cpu_loop();
qemu_mutex_lock_iothread();
qemu_add_opts(&qemu_icount_opts);
qemu_add_opts(&qemu_semihosting_config_opts);
qemu_add_opts(&qemu_fw_cfg_opts);
+ module_call_init(MODULE_INIT_OPTS);
runstate_init();
QLIST_INIT (&vm_change_state_head);
os_setup_early_signal_handling();
- module_call_init(MODULE_INIT_MACHINE);
cpu_model = NULL;
snapshot = 0;
cyls = heads = secs = 0;
popt = lookup_opt(argc, argv, &optarg, &optind);
if (!(popt->arch_mask & arch_type)) {
- printf("Option %s not supported for this target\n", popt->name);
+ error_report("Option not supported for this target");
exit(1);
}
switch(popt->index) {
display_type = select_display(optarg);
break;
case QEMU_OPTION_nographic:
- display_type = DT_NOGRAPHIC;
+ olist = qemu_find_opts("machine");
+ qemu_opts_parse_noisily(olist, "graphics=off", false);
+ nographic = true;
+ display_type = DT_NONE;
break;
case QEMU_OPTION_curses:
#ifdef CONFIG_CURSES
fd_bootchk = 0;
break;
case QEMU_OPTION_netdev:
+ default_net = 0;
if (net_client_parse(qemu_find_opts("netdev"), optarg) == -1) {
exit(1);
}
break;
case QEMU_OPTION_net:
+ default_net = 0;
if (net_client_parse(qemu_find_opts("net"), optarg) == -1) {
exit(1);
}
case QEMU_OPTION_D:
log_file = optarg;
break;
+ case QEMU_OPTION_DFILTER:
+ qemu_set_dfilter_ranges(optarg, &error_fatal);
+ break;
case QEMU_OPTION_s:
add_device_config(DEV_GDB, "tcp::" DEFAULT_GDBSTUB_PORT);
break;
add_device_config(DEV_GDB, optarg);
break;
case QEMU_OPTION_L:
- if (data_dir_idx < ARRAY_SIZE(data_dir)) {
+ if (is_help_option(optarg)) {
+ list_data_dirs = true;
+ } else if (data_dir_idx < ARRAY_SIZE(data_dir)) {
data_dir[data_dir_idx++] = optarg;
}
break;
win2k_install_hack = 1;
break;
case QEMU_OPTION_rtc_td_hack: {
- static GlobalProperty slew_lost_ticks[] = {
- {
- .driver = "mc146818rtc",
- .property = "lost_tick_policy",
- .value = "slew",
- },
- { /* end of list */ }
+ static GlobalProperty slew_lost_ticks = {
+ .driver = "mc146818rtc",
+ .property = "lost_tick_policy",
+ .value = "slew",
};
- qdev_prop_register_global_list(slew_lost_ticks);
+ qdev_prop_register_global(&slew_lost_ticks);
break;
}
case QEMU_OPTION_acpitable:
break;
}
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 */ }
+ static GlobalProperty kvm_pit_lost_tick_policy = {
+ .driver = "kvm-pit",
+ .property = "lost_tick_policy",
+ .value = "discard",
};
error_report("warning: deprecated, replaced by "
"-global kvm-pit.lost_tick_policy=discard");
- qdev_prop_register_global_list(kvm_pit_lost_tick_policy);
+ qdev_prop_register_global(&kvm_pit_lost_tick_policy);
break;
}
case QEMU_OPTION_usb:
}
break;
case QEMU_OPTION_vnc:
- {
-#ifdef CONFIG_VNC
- Error *local_err = NULL;
-
- if (vnc_parse(optarg, &local_err) == NULL) {
- error_report_err(local_err);
- exit(1);
- }
-#else
- error_report("VNC support is disabled");
- exit(1);
-#endif
+ vnc_parse(optarg, &error_fatal);
break;
- }
case QEMU_OPTION_no_acpi:
acpi_enabled = 0;
break;
break;
case QEMU_OPTION_xen_domid:
if (!(xen_available())) {
- printf("Option %s not supported for this target\n", popt->name);
+ error_report("Option not supported for this target");
exit(1);
}
xen_domid = atoi(optarg);
break;
case QEMU_OPTION_xen_create:
if (!(xen_available())) {
- printf("Option %s not supported for this target\n", popt->name);
+ error_report("Option not supported for this target");
exit(1);
}
xen_mode = XEN_CREATE;
break;
case QEMU_OPTION_xen_attach:
if (!(xen_available())) {
- printf("Option %s not supported for this target\n", popt->name);
+ error_report("Option not supported for this target");
exit(1);
}
xen_mode = XEN_ATTACH;
qemu_set_hw_version(machine_class->hw_version);
}
- /* 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();
-
if (cpu_model && is_help_option(cpu_model)) {
list_cpus(stdout, &fprintf, cpu_model);
exit(0);
}
+ if (!trace_init_backends()) {
+ exit(1);
+ }
trace_init_file(trace_file);
/* Open the logfile at this point and set the log mask if necessary.
*/
if (log_file) {
- qemu_set_log_filename(log_file);
+ qemu_set_log_filename(log_file, &error_fatal);
}
if (log_mask) {
qemu_set_log(0);
}
- if (!trace_init_backends()) {
- exit(1);
- }
-
/* If no data_dir is specified then try to find it relative to the
executable path. */
if (data_dir_idx < ARRAY_SIZE(data_dir)) {
data_dir[data_dir_idx++] = CONFIG_QEMU_DATADIR;
}
+ /* -L help lists the data directories and exits. */
+ if (list_data_dirs) {
+ for (i = 0; i < data_dir_idx; i++) {
+ printf("%s\n", data_dir[i]);
+ }
+ exit(0);
+ }
+
smp_parse(qemu_opts_find(qemu_find_opts("smp-opts"), NULL));
machine_class->max_cpus = machine_class->max_cpus ?: 1; /* Default to UP */
* -nographic _and_ redirects all ports explicitly - this is valid
* usage, -nographic is just a no-op in this case.
*/
- if (display_type == DT_NOGRAPHIC
+ if (nographic
&& (default_parallel || default_serial
|| default_monitor || default_virtcon)) {
error_report("-nographic cannot be used with -daemonize");
#endif
}
- if (display_type == DT_NOGRAPHIC) {
+ if (nographic) {
if (default_parallel)
add_device_config(DEV_PARALLEL, "null");
if (default_serial && default_monitor) {
if (display_type == DT_DEFAULT && !display_remote) {
#if defined(CONFIG_GTK)
display_type = DT_GTK;
-#elif defined(CONFIG_SDL) || defined(CONFIG_COCOA)
+#elif defined(CONFIG_SDL)
display_type = DT_SDL;
+#elif defined(CONFIG_COCOA)
+ display_type = DT_COCOA;
#elif defined(CONFIG_VNC)
vnc_parse("localhost:0,to=99,id=default", &error_abort);
show_vnc_port = 1;
"ignoring option");
}
-#if defined(CONFIG_GTK)
if (display_type == DT_GTK) {
early_gtk_display_init(request_opengl);
}
-#endif
-#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)
error_report("OpenGL is not supported by the display");
if (qemu_opts_foreach(qemu_find_opts("object"),
user_creatable_add_opts_foreach,
- object_create_initial, &err)) {
- error_report_err(err);
+ object_create_initial, NULL)) {
exit(1);
}
os_set_line_buffering();
-#ifdef CONFIG_SPICE
/* spice needs the timers to be initialized by this point */
qemu_spice_init();
-#endif
cpu_ticks_init();
if (icount_opts) {
/* clean up network at qemu process termination */
atexit(&net_cleanup);
+ if (default_net) {
+ QemuOptsList *net = qemu_find_opts("net");
+ qemu_opts_set(net, NULL, "type", "nic", &error_abort);
+#ifdef CONFIG_SLIRP
+ qemu_opts_set(net, NULL, "type", "user", &error_abort);
+#endif
+ }
+
if (net_init_clients() < 0) {
exit(1);
}
if (qemu_opts_foreach(qemu_find_opts("object"),
user_creatable_add_opts_foreach,
- object_create_delayed, &err)) {
- error_report_err(err);
+ object_create_delayed, NULL)) {
exit(1);
}
if (default_vga) {
if (machine_class->default_display) {
vga_model = machine_class->default_display;
- } else if (cirrus_vga_available()) {
+ } else if (vga_interface_available(VGA_CIRRUS)) {
vga_model = "cirrus";
- } else if (vga_available()) {
+ } else if (vga_interface_available(VGA_STD)) {
vga_model = "std";
}
}
}
if (machine_class->compat_props) {
- qdev_prop_register_global_list(machine_class->compat_props);
+ GlobalProperty *p;
+ for (i = 0; i < machine_class->compat_props->len; i++) {
+ p = g_array_index(machine_class->compat_props, GlobalProperty *, i);
+ qdev_prop_register_global(p);
+ }
}
qemu_add_globals();
}
/* init USB devices */
- if (usb_enabled()) {
+ if (machine_usb(current_machine)) {
if (foreach_device_config(DEV_USB, usb_parse) < 0)
exit(1);
}
igd_gfx_passthru();
/* init generic devices */
+ rom_set_order_override(FW_CFG_ORDER_OVERRIDE_DEVICE);
if (qemu_opts_foreach(qemu_find_opts("device"),
device_init_func, NULL, NULL)) {
exit(1);
}
+ rom_reset_order_override();
/* Did we create any drives that we failed to create a device for? */
drive_check_orphaned();
- net_check_clients();
+ /* Don't warn about the default network setup that you get if
+ * no command line -net or -netdev options are specified. There
+ * are two cases that we would otherwise complain about:
+ * (1) board doesn't support a NIC but the implicit "-net nic"
+ * requested one
+ * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
+ * sets up a nic that isn't connected to anything.
+ */
+ if (!default_net) {
+ net_check_clients();
+ }
+
if (boot_once) {
qemu_boot_set(boot_once, &error_fatal);
/* init local displays */
switch (display_type) {
- case DT_NOGRAPHIC:
- (void)ds; /* avoid warning if no display is configured */
- break;
-#if defined(CONFIG_CURSES)
case DT_CURSES:
curses_display_init(ds, full_screen);
break;
-#endif
-#if defined(CONFIG_SDL)
case DT_SDL:
sdl_display_init(ds, full_screen, no_frame);
break;
-#elif defined(CONFIG_COCOA)
- case DT_SDL:
+ case DT_COCOA:
cocoa_display_init(ds, full_screen);
break;
-#endif
-#if defined(CONFIG_GTK)
case DT_GTK:
gtk_display_init(ds, full_screen, grab_on_hover);
break;
-#endif
default:
break;
}
/* must be after terminal init, SDL library changes signal handlers */
os_setup_signal_handling();
-#ifdef CONFIG_VNC
/* init remote displays */
+#ifdef CONFIG_VNC
qemu_opts_foreach(qemu_find_opts("vnc"),
vnc_init_func, NULL, NULL);
+#endif
if (show_vnc_port) {
char *ret = vnc_display_local_addr("default");
printf("VNC server running on '%s'\n", ret);
g_free(ret);
}
-#endif
-#ifdef CONFIG_SPICE
+
if (using_spice) {
qemu_spice_display_init();
}
-#endif
if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) {
exit(1);
projects / qemu.git / blobdiff