4 * Copyright (C) 2014 Red Hat Inc
7 * Marcel Apfelbaum <marcel.a@redhat.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
14 #include "hw/boards.h"
15 #include "qapi/error.h"
16 #include "qapi-visit.h"
17 #include "qapi/visitor.h"
18 #include "hw/sysbus.h"
19 #include "sysemu/sysemu.h"
20 #include "qemu/error-report.h"
21 #include "qemu/cutils.h"
23 static char *machine_get_accel(Object
*obj
, Error
**errp
)
25 MachineState
*ms
= MACHINE(obj
);
27 return g_strdup(ms
->accel
);
30 static void machine_set_accel(Object
*obj
, const char *value
, Error
**errp
)
32 MachineState
*ms
= MACHINE(obj
);
35 ms
->accel
= g_strdup(value
);
38 static void machine_set_kernel_irqchip(Object
*obj
, Visitor
*v
,
39 const char *name
, void *opaque
,
43 MachineState
*ms
= MACHINE(obj
);
46 visit_type_OnOffSplit(v
, name
, &mode
, &err
);
48 error_propagate(errp
, err
);
53 ms
->kernel_irqchip_allowed
= true;
54 ms
->kernel_irqchip_required
= true;
55 ms
->kernel_irqchip_split
= false;
57 case ON_OFF_SPLIT_OFF
:
58 ms
->kernel_irqchip_allowed
= false;
59 ms
->kernel_irqchip_required
= false;
60 ms
->kernel_irqchip_split
= false;
62 case ON_OFF_SPLIT_SPLIT
:
63 ms
->kernel_irqchip_allowed
= true;
64 ms
->kernel_irqchip_required
= true;
65 ms
->kernel_irqchip_split
= true;
68 /* The value was checked in visit_type_OnOffSplit() above. If
69 * we get here, then something is wrong in QEMU.
76 static void machine_get_kvm_shadow_mem(Object
*obj
, Visitor
*v
,
77 const char *name
, void *opaque
,
80 MachineState
*ms
= MACHINE(obj
);
81 int64_t value
= ms
->kvm_shadow_mem
;
83 visit_type_int(v
, name
, &value
, errp
);
86 static void machine_set_kvm_shadow_mem(Object
*obj
, Visitor
*v
,
87 const char *name
, void *opaque
,
90 MachineState
*ms
= MACHINE(obj
);
94 visit_type_int(v
, name
, &value
, &error
);
96 error_propagate(errp
, error
);
100 ms
->kvm_shadow_mem
= value
;
103 static char *machine_get_kernel(Object
*obj
, Error
**errp
)
105 MachineState
*ms
= MACHINE(obj
);
107 return g_strdup(ms
->kernel_filename
);
110 static void machine_set_kernel(Object
*obj
, const char *value
, Error
**errp
)
112 MachineState
*ms
= MACHINE(obj
);
114 g_free(ms
->kernel_filename
);
115 ms
->kernel_filename
= g_strdup(value
);
118 static char *machine_get_initrd(Object
*obj
, Error
**errp
)
120 MachineState
*ms
= MACHINE(obj
);
122 return g_strdup(ms
->initrd_filename
);
125 static void machine_set_initrd(Object
*obj
, const char *value
, Error
**errp
)
127 MachineState
*ms
= MACHINE(obj
);
129 g_free(ms
->initrd_filename
);
130 ms
->initrd_filename
= g_strdup(value
);
133 static char *machine_get_append(Object
*obj
, Error
**errp
)
135 MachineState
*ms
= MACHINE(obj
);
137 return g_strdup(ms
->kernel_cmdline
);
140 static void machine_set_append(Object
*obj
, const char *value
, Error
**errp
)
142 MachineState
*ms
= MACHINE(obj
);
144 g_free(ms
->kernel_cmdline
);
145 ms
->kernel_cmdline
= g_strdup(value
);
148 static char *machine_get_dtb(Object
*obj
, Error
**errp
)
150 MachineState
*ms
= MACHINE(obj
);
152 return g_strdup(ms
->dtb
);
155 static void machine_set_dtb(Object
*obj
, const char *value
, Error
**errp
)
157 MachineState
*ms
= MACHINE(obj
);
160 ms
->dtb
= g_strdup(value
);
163 static char *machine_get_dumpdtb(Object
*obj
, Error
**errp
)
165 MachineState
*ms
= MACHINE(obj
);
167 return g_strdup(ms
->dumpdtb
);
170 static void machine_set_dumpdtb(Object
*obj
, const char *value
, Error
**errp
)
172 MachineState
*ms
= MACHINE(obj
);
175 ms
->dumpdtb
= g_strdup(value
);
178 static void machine_get_phandle_start(Object
*obj
, Visitor
*v
,
179 const char *name
, void *opaque
,
182 MachineState
*ms
= MACHINE(obj
);
183 int64_t value
= ms
->phandle_start
;
185 visit_type_int(v
, name
, &value
, errp
);
188 static void machine_set_phandle_start(Object
*obj
, Visitor
*v
,
189 const char *name
, void *opaque
,
192 MachineState
*ms
= MACHINE(obj
);
196 visit_type_int(v
, name
, &value
, &error
);
198 error_propagate(errp
, error
);
202 ms
->phandle_start
= value
;
205 static char *machine_get_dt_compatible(Object
*obj
, Error
**errp
)
207 MachineState
*ms
= MACHINE(obj
);
209 return g_strdup(ms
->dt_compatible
);
212 static void machine_set_dt_compatible(Object
*obj
, const char *value
, Error
**errp
)
214 MachineState
*ms
= MACHINE(obj
);
216 g_free(ms
->dt_compatible
);
217 ms
->dt_compatible
= g_strdup(value
);
220 static bool machine_get_dump_guest_core(Object
*obj
, Error
**errp
)
222 MachineState
*ms
= MACHINE(obj
);
224 return ms
->dump_guest_core
;
227 static void machine_set_dump_guest_core(Object
*obj
, bool value
, Error
**errp
)
229 MachineState
*ms
= MACHINE(obj
);
231 ms
->dump_guest_core
= value
;
234 static bool machine_get_mem_merge(Object
*obj
, Error
**errp
)
236 MachineState
*ms
= MACHINE(obj
);
238 return ms
->mem_merge
;
241 static void machine_set_mem_merge(Object
*obj
, bool value
, Error
**errp
)
243 MachineState
*ms
= MACHINE(obj
);
245 ms
->mem_merge
= value
;
248 static bool machine_get_usb(Object
*obj
, Error
**errp
)
250 MachineState
*ms
= MACHINE(obj
);
255 static void machine_set_usb(Object
*obj
, bool value
, Error
**errp
)
257 MachineState
*ms
= MACHINE(obj
);
260 ms
->usb_disabled
= !value
;
263 static bool machine_get_graphics(Object
*obj
, Error
**errp
)
265 MachineState
*ms
= MACHINE(obj
);
267 return ms
->enable_graphics
;
270 static void machine_set_graphics(Object
*obj
, bool value
, Error
**errp
)
272 MachineState
*ms
= MACHINE(obj
);
274 ms
->enable_graphics
= value
;
277 static bool machine_get_igd_gfx_passthru(Object
*obj
, Error
**errp
)
279 MachineState
*ms
= MACHINE(obj
);
281 return ms
->igd_gfx_passthru
;
284 static void machine_set_igd_gfx_passthru(Object
*obj
, bool value
, Error
**errp
)
286 MachineState
*ms
= MACHINE(obj
);
288 ms
->igd_gfx_passthru
= value
;
291 static char *machine_get_firmware(Object
*obj
, Error
**errp
)
293 MachineState
*ms
= MACHINE(obj
);
295 return g_strdup(ms
->firmware
);
298 static void machine_set_firmware(Object
*obj
, const char *value
, Error
**errp
)
300 MachineState
*ms
= MACHINE(obj
);
302 g_free(ms
->firmware
);
303 ms
->firmware
= g_strdup(value
);
306 static void machine_set_suppress_vmdesc(Object
*obj
, bool value
, Error
**errp
)
308 MachineState
*ms
= MACHINE(obj
);
310 ms
->suppress_vmdesc
= value
;
313 static bool machine_get_suppress_vmdesc(Object
*obj
, Error
**errp
)
315 MachineState
*ms
= MACHINE(obj
);
317 return ms
->suppress_vmdesc
;
320 static void machine_set_enforce_config_section(Object
*obj
, bool value
,
323 MachineState
*ms
= MACHINE(obj
);
325 ms
->enforce_config_section
= value
;
328 static bool machine_get_enforce_config_section(Object
*obj
, Error
**errp
)
330 MachineState
*ms
= MACHINE(obj
);
332 return ms
->enforce_config_section
;
335 static void error_on_sysbus_device(SysBusDevice
*sbdev
, void *opaque
)
337 error_report("Option '-device %s' cannot be handled by this machine",
338 object_class_get_name(object_get_class(OBJECT(sbdev
))));
342 static void machine_init_notify(Notifier
*notifier
, void *data
)
344 Object
*machine
= qdev_get_machine();
345 ObjectClass
*oc
= object_get_class(machine
);
346 MachineClass
*mc
= MACHINE_CLASS(oc
);
348 if (mc
->has_dynamic_sysbus
) {
349 /* Our machine can handle dynamic sysbus devices, we're all good */
354 * Loop through all dynamically created devices and check whether there
355 * are sysbus devices among them. If there are, error out.
357 foreach_dynamic_sysbus_device(error_on_sysbus_device
, NULL
);
360 HotpluggableCPUList
*machine_query_hotpluggable_cpus(MachineState
*machine
)
364 HotpluggableCPUList
*head
= NULL
;
365 const char *cpu_type
;
367 cpu
= machine
->possible_cpus
->cpus
[0].cpu
;
368 assert(cpu
); /* Boot cpu is always present */
369 cpu_type
= object_get_typename(cpu
);
370 for (i
= 0; i
< machine
->possible_cpus
->len
; i
++) {
371 HotpluggableCPUList
*list_item
= g_new0(typeof(*list_item
), 1);
372 HotpluggableCPU
*cpu_item
= g_new0(typeof(*cpu_item
), 1);
374 cpu_item
->type
= g_strdup(cpu_type
);
375 cpu_item
->vcpus_count
= machine
->possible_cpus
->cpus
[i
].vcpus_count
;
376 cpu_item
->props
= g_memdup(&machine
->possible_cpus
->cpus
[i
].props
,
377 sizeof(*cpu_item
->props
));
379 cpu
= machine
->possible_cpus
->cpus
[i
].cpu
;
381 cpu_item
->has_qom_path
= true;
382 cpu_item
->qom_path
= object_get_canonical_path(cpu
);
384 list_item
->value
= cpu_item
;
385 list_item
->next
= head
;
391 static void machine_class_init(ObjectClass
*oc
, void *data
)
393 MachineClass
*mc
= MACHINE_CLASS(oc
);
395 /* Default 128 MB as guest ram size */
396 mc
->default_ram_size
= 128 * M_BYTE
;
397 mc
->rom_file_has_mr
= true;
399 /* numa node memory size aligned on 8MB by default.
400 * On Linux, each node's border has to be 8MB aligned
402 mc
->numa_mem_align_shift
= 23;
404 object_class_property_add_str(oc
, "accel",
405 machine_get_accel
, machine_set_accel
, &error_abort
);
406 object_class_property_set_description(oc
, "accel",
407 "Accelerator list", &error_abort
);
409 object_class_property_add(oc
, "kernel-irqchip", "OnOffSplit",
410 NULL
, machine_set_kernel_irqchip
,
411 NULL
, NULL
, &error_abort
);
412 object_class_property_set_description(oc
, "kernel-irqchip",
413 "Configure KVM in-kernel irqchip", &error_abort
);
415 object_class_property_add(oc
, "kvm-shadow-mem", "int",
416 machine_get_kvm_shadow_mem
, machine_set_kvm_shadow_mem
,
417 NULL
, NULL
, &error_abort
);
418 object_class_property_set_description(oc
, "kvm-shadow-mem",
419 "KVM shadow MMU size", &error_abort
);
421 object_class_property_add_str(oc
, "kernel",
422 machine_get_kernel
, machine_set_kernel
, &error_abort
);
423 object_class_property_set_description(oc
, "kernel",
424 "Linux kernel image file", &error_abort
);
426 object_class_property_add_str(oc
, "initrd",
427 machine_get_initrd
, machine_set_initrd
, &error_abort
);
428 object_class_property_set_description(oc
, "initrd",
429 "Linux initial ramdisk file", &error_abort
);
431 object_class_property_add_str(oc
, "append",
432 machine_get_append
, machine_set_append
, &error_abort
);
433 object_class_property_set_description(oc
, "append",
434 "Linux kernel command line", &error_abort
);
436 object_class_property_add_str(oc
, "dtb",
437 machine_get_dtb
, machine_set_dtb
, &error_abort
);
438 object_class_property_set_description(oc
, "dtb",
439 "Linux kernel device tree file", &error_abort
);
441 object_class_property_add_str(oc
, "dumpdtb",
442 machine_get_dumpdtb
, machine_set_dumpdtb
, &error_abort
);
443 object_class_property_set_description(oc
, "dumpdtb",
444 "Dump current dtb to a file and quit", &error_abort
);
446 object_class_property_add(oc
, "phandle-start", "int",
447 machine_get_phandle_start
, machine_set_phandle_start
,
448 NULL
, NULL
, &error_abort
);
449 object_class_property_set_description(oc
, "phandle-start",
450 "The first phandle ID we may generate dynamically", &error_abort
);
452 object_class_property_add_str(oc
, "dt-compatible",
453 machine_get_dt_compatible
, machine_set_dt_compatible
, &error_abort
);
454 object_class_property_set_description(oc
, "dt-compatible",
455 "Overrides the \"compatible\" property of the dt root node",
458 object_class_property_add_bool(oc
, "dump-guest-core",
459 machine_get_dump_guest_core
, machine_set_dump_guest_core
, &error_abort
);
460 object_class_property_set_description(oc
, "dump-guest-core",
461 "Include guest memory in a core dump", &error_abort
);
463 object_class_property_add_bool(oc
, "mem-merge",
464 machine_get_mem_merge
, machine_set_mem_merge
, &error_abort
);
465 object_class_property_set_description(oc
, "mem-merge",
466 "Enable/disable memory merge support", &error_abort
);
468 object_class_property_add_bool(oc
, "usb",
469 machine_get_usb
, machine_set_usb
, &error_abort
);
470 object_class_property_set_description(oc
, "usb",
471 "Set on/off to enable/disable usb", &error_abort
);
473 object_class_property_add_bool(oc
, "graphics",
474 machine_get_graphics
, machine_set_graphics
, &error_abort
);
475 object_class_property_set_description(oc
, "graphics",
476 "Set on/off to enable/disable graphics emulation", &error_abort
);
478 object_class_property_add_bool(oc
, "igd-passthru",
479 machine_get_igd_gfx_passthru
, machine_set_igd_gfx_passthru
,
481 object_class_property_set_description(oc
, "igd-passthru",
482 "Set on/off to enable/disable igd passthrou", &error_abort
);
484 object_class_property_add_str(oc
, "firmware",
485 machine_get_firmware
, machine_set_firmware
,
487 object_class_property_set_description(oc
, "firmware",
488 "Firmware image", &error_abort
);
490 object_class_property_add_bool(oc
, "suppress-vmdesc",
491 machine_get_suppress_vmdesc
, machine_set_suppress_vmdesc
,
493 object_class_property_set_description(oc
, "suppress-vmdesc",
494 "Set on to disable self-describing migration", &error_abort
);
496 object_class_property_add_bool(oc
, "enforce-config-section",
497 machine_get_enforce_config_section
, machine_set_enforce_config_section
,
499 object_class_property_set_description(oc
, "enforce-config-section",
500 "Set on to enforce configuration section migration", &error_abort
);
503 static void machine_class_base_init(ObjectClass
*oc
, void *data
)
505 if (!object_class_is_abstract(oc
)) {
506 MachineClass
*mc
= MACHINE_CLASS(oc
);
507 const char *cname
= object_class_get_name(oc
);
508 assert(g_str_has_suffix(cname
, TYPE_MACHINE_SUFFIX
));
509 mc
->name
= g_strndup(cname
,
510 strlen(cname
) - strlen(TYPE_MACHINE_SUFFIX
));
514 static void machine_initfn(Object
*obj
)
516 MachineState
*ms
= MACHINE(obj
);
518 ms
->kernel_irqchip_allowed
= true;
519 ms
->kvm_shadow_mem
= -1;
520 ms
->dump_guest_core
= true;
521 ms
->mem_merge
= true;
522 ms
->enable_graphics
= true;
524 /* Register notifier when init is done for sysbus sanity checks */
525 ms
->sysbus_notifier
.notify
= machine_init_notify
;
526 qemu_add_machine_init_done_notifier(&ms
->sysbus_notifier
);
529 static void machine_finalize(Object
*obj
)
531 MachineState
*ms
= MACHINE(obj
);
534 g_free(ms
->kernel_filename
);
535 g_free(ms
->initrd_filename
);
536 g_free(ms
->kernel_cmdline
);
539 g_free(ms
->dt_compatible
);
540 g_free(ms
->firmware
);
543 bool machine_usb(MachineState
*machine
)
548 bool machine_kernel_irqchip_allowed(MachineState
*machine
)
550 return machine
->kernel_irqchip_allowed
;
553 bool machine_kernel_irqchip_required(MachineState
*machine
)
555 return machine
->kernel_irqchip_required
;
558 bool machine_kernel_irqchip_split(MachineState
*machine
)
560 return machine
->kernel_irqchip_split
;
563 int machine_kvm_shadow_mem(MachineState
*machine
)
565 return machine
->kvm_shadow_mem
;
568 int machine_phandle_start(MachineState
*machine
)
570 return machine
->phandle_start
;
573 bool machine_dump_guest_core(MachineState
*machine
)
575 return machine
->dump_guest_core
;
578 bool machine_mem_merge(MachineState
*machine
)
580 return machine
->mem_merge
;
583 static void machine_class_finalize(ObjectClass
*klass
, void *data
)
585 MachineClass
*mc
= MACHINE_CLASS(klass
);
587 if (mc
->compat_props
) {
588 g_array_free(mc
->compat_props
, true);
593 static void register_compat_prop(const char *driver
,
594 const char *property
,
597 GlobalProperty
*p
= g_new0(GlobalProperty
, 1);
598 /* Machine compat_props must never cause errors: */
599 p
->errp
= &error_abort
;
601 p
->property
= property
;
603 qdev_prop_register_global(p
);
606 static void machine_register_compat_for_subclass(ObjectClass
*oc
, void *opaque
)
608 GlobalProperty
*p
= opaque
;
609 register_compat_prop(object_class_get_name(oc
), p
->property
, p
->value
);
612 void machine_register_compat_props(MachineState
*machine
)
614 MachineClass
*mc
= MACHINE_GET_CLASS(machine
);
619 if (!mc
->compat_props
) {
623 for (i
= 0; i
< mc
->compat_props
->len
; i
++) {
624 p
= g_array_index(mc
->compat_props
, GlobalProperty
*, i
);
625 oc
= object_class_by_name(p
->driver
);
626 if (oc
&& object_class_is_abstract(oc
)) {
627 /* temporary hack to make sure we do not override
628 * globals set explicitly on -global: if an abstract class
629 * is on compat_props, register globals for all its
630 * non-abstract subtypes instead.
632 * This doesn't solve the problem for cases where
633 * a non-abstract typename mentioned on compat_props
634 * has subclasses, like spapr-pci-host-bridge.
636 object_class_foreach(machine_register_compat_for_subclass
,
637 p
->driver
, false, p
);
639 register_compat_prop(p
->driver
, p
->property
, p
->value
);
644 static const TypeInfo machine_info
= {
645 .name
= TYPE_MACHINE
,
646 .parent
= TYPE_OBJECT
,
648 .class_size
= sizeof(MachineClass
),
649 .class_init
= machine_class_init
,
650 .class_base_init
= machine_class_base_init
,
651 .class_finalize
= machine_class_finalize
,
652 .instance_size
= sizeof(MachineState
),
653 .instance_init
= machine_initfn
,
654 .instance_finalize
= machine_finalize
,
657 static void machine_register_types(void)
659 type_register_static(&machine_info
);
662 type_init(machine_register_types
)