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 object_class_property_add_str(oc
, "accel",
400 machine_get_accel
, machine_set_accel
, &error_abort
);
401 object_class_property_set_description(oc
, "accel",
402 "Accelerator list", &error_abort
);
404 object_class_property_add(oc
, "kernel-irqchip", "OnOffSplit",
405 NULL
, machine_set_kernel_irqchip
,
406 NULL
, NULL
, &error_abort
);
407 object_class_property_set_description(oc
, "kernel-irqchip",
408 "Configure KVM in-kernel irqchip", &error_abort
);
410 object_class_property_add(oc
, "kvm-shadow-mem", "int",
411 machine_get_kvm_shadow_mem
, machine_set_kvm_shadow_mem
,
412 NULL
, NULL
, &error_abort
);
413 object_class_property_set_description(oc
, "kvm-shadow-mem",
414 "KVM shadow MMU size", &error_abort
);
416 object_class_property_add_str(oc
, "kernel",
417 machine_get_kernel
, machine_set_kernel
, &error_abort
);
418 object_class_property_set_description(oc
, "kernel",
419 "Linux kernel image file", &error_abort
);
421 object_class_property_add_str(oc
, "initrd",
422 machine_get_initrd
, machine_set_initrd
, &error_abort
);
423 object_class_property_set_description(oc
, "initrd",
424 "Linux initial ramdisk file", &error_abort
);
426 object_class_property_add_str(oc
, "append",
427 machine_get_append
, machine_set_append
, &error_abort
);
428 object_class_property_set_description(oc
, "append",
429 "Linux kernel command line", &error_abort
);
431 object_class_property_add_str(oc
, "dtb",
432 machine_get_dtb
, machine_set_dtb
, &error_abort
);
433 object_class_property_set_description(oc
, "dtb",
434 "Linux kernel device tree file", &error_abort
);
436 object_class_property_add_str(oc
, "dumpdtb",
437 machine_get_dumpdtb
, machine_set_dumpdtb
, &error_abort
);
438 object_class_property_set_description(oc
, "dumpdtb",
439 "Dump current dtb to a file and quit", &error_abort
);
441 object_class_property_add(oc
, "phandle-start", "int",
442 machine_get_phandle_start
, machine_set_phandle_start
,
443 NULL
, NULL
, &error_abort
);
444 object_class_property_set_description(oc
, "phandle-start",
445 "The first phandle ID we may generate dynamically", &error_abort
);
447 object_class_property_add_str(oc
, "dt-compatible",
448 machine_get_dt_compatible
, machine_set_dt_compatible
, &error_abort
);
449 object_class_property_set_description(oc
, "dt-compatible",
450 "Overrides the \"compatible\" property of the dt root node",
453 object_class_property_add_bool(oc
, "dump-guest-core",
454 machine_get_dump_guest_core
, machine_set_dump_guest_core
, &error_abort
);
455 object_class_property_set_description(oc
, "dump-guest-core",
456 "Include guest memory in a core dump", &error_abort
);
458 object_class_property_add_bool(oc
, "mem-merge",
459 machine_get_mem_merge
, machine_set_mem_merge
, &error_abort
);
460 object_class_property_set_description(oc
, "mem-merge",
461 "Enable/disable memory merge support", &error_abort
);
463 object_class_property_add_bool(oc
, "usb",
464 machine_get_usb
, machine_set_usb
, &error_abort
);
465 object_class_property_set_description(oc
, "usb",
466 "Set on/off to enable/disable usb", &error_abort
);
468 object_class_property_add_bool(oc
, "graphics",
469 machine_get_graphics
, machine_set_graphics
, &error_abort
);
470 object_class_property_set_description(oc
, "graphics",
471 "Set on/off to enable/disable graphics emulation", &error_abort
);
473 object_class_property_add_bool(oc
, "igd-passthru",
474 machine_get_igd_gfx_passthru
, machine_set_igd_gfx_passthru
,
476 object_class_property_set_description(oc
, "igd-passthru",
477 "Set on/off to enable/disable igd passthrou", &error_abort
);
479 object_class_property_add_str(oc
, "firmware",
480 machine_get_firmware
, machine_set_firmware
,
482 object_class_property_set_description(oc
, "firmware",
483 "Firmware image", &error_abort
);
485 object_class_property_add_bool(oc
, "suppress-vmdesc",
486 machine_get_suppress_vmdesc
, machine_set_suppress_vmdesc
,
488 object_class_property_set_description(oc
, "suppress-vmdesc",
489 "Set on to disable self-describing migration", &error_abort
);
491 object_class_property_add_bool(oc
, "enforce-config-section",
492 machine_get_enforce_config_section
, machine_set_enforce_config_section
,
494 object_class_property_set_description(oc
, "enforce-config-section",
495 "Set on to enforce configuration section migration", &error_abort
);
498 static void machine_class_base_init(ObjectClass
*oc
, void *data
)
500 if (!object_class_is_abstract(oc
)) {
501 MachineClass
*mc
= MACHINE_CLASS(oc
);
502 const char *cname
= object_class_get_name(oc
);
503 assert(g_str_has_suffix(cname
, TYPE_MACHINE_SUFFIX
));
504 mc
->name
= g_strndup(cname
,
505 strlen(cname
) - strlen(TYPE_MACHINE_SUFFIX
));
509 static void machine_initfn(Object
*obj
)
511 MachineState
*ms
= MACHINE(obj
);
513 ms
->kernel_irqchip_allowed
= true;
514 ms
->kvm_shadow_mem
= -1;
515 ms
->dump_guest_core
= true;
516 ms
->mem_merge
= true;
517 ms
->enable_graphics
= true;
519 /* Register notifier when init is done for sysbus sanity checks */
520 ms
->sysbus_notifier
.notify
= machine_init_notify
;
521 qemu_add_machine_init_done_notifier(&ms
->sysbus_notifier
);
524 static void machine_finalize(Object
*obj
)
526 MachineState
*ms
= MACHINE(obj
);
529 g_free(ms
->kernel_filename
);
530 g_free(ms
->initrd_filename
);
531 g_free(ms
->kernel_cmdline
);
534 g_free(ms
->dt_compatible
);
535 g_free(ms
->firmware
);
538 bool machine_usb(MachineState
*machine
)
543 bool machine_kernel_irqchip_allowed(MachineState
*machine
)
545 return machine
->kernel_irqchip_allowed
;
548 bool machine_kernel_irqchip_required(MachineState
*machine
)
550 return machine
->kernel_irqchip_required
;
553 bool machine_kernel_irqchip_split(MachineState
*machine
)
555 return machine
->kernel_irqchip_split
;
558 int machine_kvm_shadow_mem(MachineState
*machine
)
560 return machine
->kvm_shadow_mem
;
563 int machine_phandle_start(MachineState
*machine
)
565 return machine
->phandle_start
;
568 bool machine_dump_guest_core(MachineState
*machine
)
570 return machine
->dump_guest_core
;
573 bool machine_mem_merge(MachineState
*machine
)
575 return machine
->mem_merge
;
578 static void machine_class_finalize(ObjectClass
*klass
, void *data
)
580 MachineClass
*mc
= MACHINE_CLASS(klass
);
582 if (mc
->compat_props
) {
583 g_array_free(mc
->compat_props
, true);
588 void machine_register_compat_props(MachineState
*machine
)
590 MachineClass
*mc
= MACHINE_GET_CLASS(machine
);
594 if (!mc
->compat_props
) {
598 for (i
= 0; i
< mc
->compat_props
->len
; i
++) {
599 p
= g_array_index(mc
->compat_props
, GlobalProperty
*, i
);
600 /* Machine compat_props must never cause errors: */
601 p
->errp
= &error_abort
;
602 qdev_prop_register_global(p
);
606 static const TypeInfo machine_info
= {
607 .name
= TYPE_MACHINE
,
608 .parent
= TYPE_OBJECT
,
610 .class_size
= sizeof(MachineClass
),
611 .class_init
= machine_class_init
,
612 .class_base_init
= machine_class_base_init
,
613 .class_finalize
= machine_class_finalize
,
614 .instance_size
= sizeof(MachineState
),
615 .instance_init
= machine_initfn
,
616 .instance_finalize
= machine_finalize
,
619 static void machine_register_types(void)
621 type_register_static(&machine_info
);
624 type_init(machine_register_types
)