1
2
3
4
5
6
7
8
9
10
11
12
13#include "qemu/osdep.h"
14#include "qemu/units.h"
15#include "hw/boards.h"
16#include "qapi/error.h"
17#include "qapi/qapi-visit-common.h"
18#include "qapi/visitor.h"
19#include "hw/sysbus.h"
20#include "sysemu/sysemu.h"
21#include "sysemu/numa.h"
22#include "qemu/error-report.h"
23#include "sysemu/qtest.h"
24
25static char *machine_get_accel(Object *obj, Error **errp)
26{
27 MachineState *ms = MACHINE(obj);
28
29 return g_strdup(ms->accel);
30}
31
32static void machine_set_accel(Object *obj, const char *value, Error **errp)
33{
34 MachineState *ms = MACHINE(obj);
35
36 g_free(ms->accel);
37 ms->accel = g_strdup(value);
38}
39
40static void machine_set_kernel_irqchip(Object *obj, Visitor *v,
41 const char *name, void *opaque,
42 Error **errp)
43{
44 Error *err = NULL;
45 MachineState *ms = MACHINE(obj);
46 OnOffSplit mode;
47
48 visit_type_OnOffSplit(v, name, &mode, &err);
49 if (err) {
50 error_propagate(errp, err);
51 return;
52 } else {
53 switch (mode) {
54 case ON_OFF_SPLIT_ON:
55 ms->kernel_irqchip_allowed = true;
56 ms->kernel_irqchip_required = true;
57 ms->kernel_irqchip_split = false;
58 break;
59 case ON_OFF_SPLIT_OFF:
60 ms->kernel_irqchip_allowed = false;
61 ms->kernel_irqchip_required = false;
62 ms->kernel_irqchip_split = false;
63 break;
64 case ON_OFF_SPLIT_SPLIT:
65 ms->kernel_irqchip_allowed = true;
66 ms->kernel_irqchip_required = true;
67 ms->kernel_irqchip_split = true;
68 break;
69 default:
70
71
72
73 abort();
74 }
75 }
76}
77
78static void machine_get_kvm_shadow_mem(Object *obj, Visitor *v,
79 const char *name, void *opaque,
80 Error **errp)
81{
82 MachineState *ms = MACHINE(obj);
83 int64_t value = ms->kvm_shadow_mem;
84
85 visit_type_int(v, name, &value, errp);
86}
87
88static void machine_set_kvm_shadow_mem(Object *obj, Visitor *v,
89 const char *name, void *opaque,
90 Error **errp)
91{
92 MachineState *ms = MACHINE(obj);
93 Error *error = NULL;
94 int64_t value;
95
96 visit_type_int(v, name, &value, &error);
97 if (error) {
98 error_propagate(errp, error);
99 return;
100 }
101
102 ms->kvm_shadow_mem = value;
103}
104
105static char *machine_get_kernel(Object *obj, Error **errp)
106{
107 MachineState *ms = MACHINE(obj);
108
109 return g_strdup(ms->kernel_filename);
110}
111
112static void machine_set_kernel(Object *obj, const char *value, Error **errp)
113{
114 MachineState *ms = MACHINE(obj);
115
116 g_free(ms->kernel_filename);
117 ms->kernel_filename = g_strdup(value);
118}
119
120static char *machine_get_initrd(Object *obj, Error **errp)
121{
122 MachineState *ms = MACHINE(obj);
123
124 return g_strdup(ms->initrd_filename);
125}
126
127static void machine_set_initrd(Object *obj, const char *value, Error **errp)
128{
129 MachineState *ms = MACHINE(obj);
130
131 g_free(ms->initrd_filename);
132 ms->initrd_filename = g_strdup(value);
133}
134
135static char *machine_get_append(Object *obj, Error **errp)
136{
137 MachineState *ms = MACHINE(obj);
138
139 return g_strdup(ms->kernel_cmdline);
140}
141
142static void machine_set_append(Object *obj, const char *value, Error **errp)
143{
144 MachineState *ms = MACHINE(obj);
145
146 g_free(ms->kernel_cmdline);
147 ms->kernel_cmdline = g_strdup(value);
148}
149
150static char *machine_get_dtb(Object *obj, Error **errp)
151{
152 MachineState *ms = MACHINE(obj);
153
154 return g_strdup(ms->dtb);
155}
156
157static void machine_set_dtb(Object *obj, const char *value, Error **errp)
158{
159 MachineState *ms = MACHINE(obj);
160
161 g_free(ms->dtb);
162 ms->dtb = g_strdup(value);
163}
164
165static char *machine_get_dumpdtb(Object *obj, Error **errp)
166{
167 MachineState *ms = MACHINE(obj);
168
169 return g_strdup(ms->dumpdtb);
170}
171
172static void machine_set_dumpdtb(Object *obj, const char *value, Error **errp)
173{
174 MachineState *ms = MACHINE(obj);
175
176 g_free(ms->dumpdtb);
177 ms->dumpdtb = g_strdup(value);
178}
179
180static void machine_get_phandle_start(Object *obj, Visitor *v,
181 const char *name, void *opaque,
182 Error **errp)
183{
184 MachineState *ms = MACHINE(obj);
185 int64_t value = ms->phandle_start;
186
187 visit_type_int(v, name, &value, errp);
188}
189
190static void machine_set_phandle_start(Object *obj, Visitor *v,
191 const char *name, void *opaque,
192 Error **errp)
193{
194 MachineState *ms = MACHINE(obj);
195 Error *error = NULL;
196 int64_t value;
197
198 visit_type_int(v, name, &value, &error);
199 if (error) {
200 error_propagate(errp, error);
201 return;
202 }
203
204 ms->phandle_start = value;
205}
206
207static char *machine_get_dt_compatible(Object *obj, Error **errp)
208{
209 MachineState *ms = MACHINE(obj);
210
211 return g_strdup(ms->dt_compatible);
212}
213
214static void machine_set_dt_compatible(Object *obj, const char *value, Error **errp)
215{
216 MachineState *ms = MACHINE(obj);
217
218 g_free(ms->dt_compatible);
219 ms->dt_compatible = g_strdup(value);
220}
221
222static bool machine_get_dump_guest_core(Object *obj, Error **errp)
223{
224 MachineState *ms = MACHINE(obj);
225
226 return ms->dump_guest_core;
227}
228
229static void machine_set_dump_guest_core(Object *obj, bool value, Error **errp)
230{
231 MachineState *ms = MACHINE(obj);
232
233 ms->dump_guest_core = value;
234}
235
236static bool machine_get_mem_merge(Object *obj, Error **errp)
237{
238 MachineState *ms = MACHINE(obj);
239
240 return ms->mem_merge;
241}
242
243static void machine_set_mem_merge(Object *obj, bool value, Error **errp)
244{
245 MachineState *ms = MACHINE(obj);
246
247 ms->mem_merge = value;
248}
249
250static bool machine_get_usb(Object *obj, Error **errp)
251{
252 MachineState *ms = MACHINE(obj);
253
254 return ms->usb;
255}
256
257static void machine_set_usb(Object *obj, bool value, Error **errp)
258{
259 MachineState *ms = MACHINE(obj);
260
261 ms->usb = value;
262 ms->usb_disabled = !value;
263}
264
265static bool machine_get_graphics(Object *obj, Error **errp)
266{
267 MachineState *ms = MACHINE(obj);
268
269 return ms->enable_graphics;
270}
271
272static void machine_set_graphics(Object *obj, bool value, Error **errp)
273{
274 MachineState *ms = MACHINE(obj);
275
276 ms->enable_graphics = value;
277}
278
279static bool machine_get_igd_gfx_passthru(Object *obj, Error **errp)
280{
281 MachineState *ms = MACHINE(obj);
282
283 return ms->igd_gfx_passthru;
284}
285
286static void machine_set_igd_gfx_passthru(Object *obj, bool value, Error **errp)
287{
288 MachineState *ms = MACHINE(obj);
289
290 ms->igd_gfx_passthru = value;
291}
292
293static char *machine_get_firmware(Object *obj, Error **errp)
294{
295 MachineState *ms = MACHINE(obj);
296
297 return g_strdup(ms->firmware);
298}
299
300static void machine_set_firmware(Object *obj, const char *value, Error **errp)
301{
302 MachineState *ms = MACHINE(obj);
303
304 g_free(ms->firmware);
305 ms->firmware = g_strdup(value);
306}
307
308static void machine_set_suppress_vmdesc(Object *obj, bool value, Error **errp)
309{
310 MachineState *ms = MACHINE(obj);
311
312 ms->suppress_vmdesc = value;
313}
314
315static bool machine_get_suppress_vmdesc(Object *obj, Error **errp)
316{
317 MachineState *ms = MACHINE(obj);
318
319 return ms->suppress_vmdesc;
320}
321
322static void machine_set_enforce_config_section(Object *obj, bool value,
323 Error **errp)
324{
325 MachineState *ms = MACHINE(obj);
326
327 ms->enforce_config_section = value;
328}
329
330static bool machine_get_enforce_config_section(Object *obj, Error **errp)
331{
332 MachineState *ms = MACHINE(obj);
333
334 return ms->enforce_config_section;
335}
336
337static char *machine_get_memory_encryption(Object *obj, Error **errp)
338{
339 MachineState *ms = MACHINE(obj);
340
341 return g_strdup(ms->memory_encryption);
342}
343
344static void machine_set_memory_encryption(Object *obj, const char *value,
345 Error **errp)
346{
347 MachineState *ms = MACHINE(obj);
348
349 g_free(ms->memory_encryption);
350 ms->memory_encryption = g_strdup(value);
351}
352
353void machine_class_allow_dynamic_sysbus_dev(MachineClass *mc, const char *type)
354{
355 strList *item = g_new0(strList, 1);
356
357 item->value = g_strdup(type);
358 item->next = mc->allowed_dynamic_sysbus_devices;
359 mc->allowed_dynamic_sysbus_devices = item;
360}
361
362static void validate_sysbus_device(SysBusDevice *sbdev, void *opaque)
363{
364 MachineState *machine = opaque;
365 MachineClass *mc = MACHINE_GET_CLASS(machine);
366 bool allowed = false;
367 strList *wl;
368
369 for (wl = mc->allowed_dynamic_sysbus_devices;
370 !allowed && wl;
371 wl = wl->next) {
372 allowed |= !!object_dynamic_cast(OBJECT(sbdev), wl->value);
373 }
374
375 if (!allowed) {
376 error_report("Option '-device %s' cannot be handled by this machine",
377 object_class_get_name(object_get_class(OBJECT(sbdev))));
378 exit(1);
379 }
380}
381
382static void machine_init_notify(Notifier *notifier, void *data)
383{
384 MachineState *machine = MACHINE(qdev_get_machine());
385
386
387
388
389
390 foreach_dynamic_sysbus_device(validate_sysbus_device, machine);
391}
392
393HotpluggableCPUList *machine_query_hotpluggable_cpus(MachineState *machine)
394{
395 int i;
396 HotpluggableCPUList *head = NULL;
397 MachineClass *mc = MACHINE_GET_CLASS(machine);
398
399
400 mc->possible_cpu_arch_ids(machine);
401
402 for (i = 0; i < machine->possible_cpus->len; i++) {
403 Object *cpu;
404 HotpluggableCPUList *list_item = g_new0(typeof(*list_item), 1);
405 HotpluggableCPU *cpu_item = g_new0(typeof(*cpu_item), 1);
406
407 cpu_item->type = g_strdup(machine->possible_cpus->cpus[i].type);
408 cpu_item->vcpus_count = machine->possible_cpus->cpus[i].vcpus_count;
409 cpu_item->props = g_memdup(&machine->possible_cpus->cpus[i].props,
410 sizeof(*cpu_item->props));
411
412 cpu = machine->possible_cpus->cpus[i].cpu;
413 if (cpu) {
414 cpu_item->has_qom_path = true;
415 cpu_item->qom_path = object_get_canonical_path(cpu);
416 }
417 list_item->value = cpu_item;
418 list_item->next = head;
419 head = list_item;
420 }
421 return head;
422}
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449void machine_set_cpu_numa_node(MachineState *machine,
450 const CpuInstanceProperties *props, Error **errp)
451{
452 MachineClass *mc = MACHINE_GET_CLASS(machine);
453 bool match = false;
454 int i;
455
456 if (!mc->possible_cpu_arch_ids) {
457 error_setg(errp, "mapping of CPUs to NUMA node is not supported");
458 return;
459 }
460
461
462 assert(props->has_node_id);
463
464
465 mc->possible_cpu_arch_ids(machine);
466
467 for (i = 0; i < machine->possible_cpus->len; i++) {
468 CPUArchId *slot = &machine->possible_cpus->cpus[i];
469
470
471 if (props->has_thread_id && !slot->props.has_thread_id) {
472 error_setg(errp, "thread-id is not supported");
473 return;
474 }
475
476 if (props->has_core_id && !slot->props.has_core_id) {
477 error_setg(errp, "core-id is not supported");
478 return;
479 }
480
481 if (props->has_socket_id && !slot->props.has_socket_id) {
482 error_setg(errp, "socket-id is not supported");
483 return;
484 }
485
486
487 if (props->has_thread_id && props->thread_id != slot->props.thread_id) {
488 continue;
489 }
490
491 if (props->has_core_id && props->core_id != slot->props.core_id) {
492 continue;
493 }
494
495 if (props->has_socket_id && props->socket_id != slot->props.socket_id) {
496 continue;
497 }
498
499
500
501
502 if (slot->props.has_node_id &&
503 slot->props.node_id != props->node_id) {
504 error_setg(errp, "CPU is already assigned to node-id: %" PRId64,
505 slot->props.node_id);
506 return;
507 }
508
509
510 match = true;
511 slot->props.node_id = props->node_id;
512 slot->props.has_node_id = props->has_node_id;
513 }
514
515 if (!match) {
516 error_setg(errp, "no match found");
517 }
518}
519
520static void machine_class_init(ObjectClass *oc, void *data)
521{
522 MachineClass *mc = MACHINE_CLASS(oc);
523
524
525 mc->default_ram_size = 128 * MiB;
526 mc->rom_file_has_mr = true;
527
528
529
530
531 mc->numa_mem_align_shift = 23;
532 mc->numa_auto_assign_ram = numa_default_auto_assign_ram;
533
534 object_class_property_add_str(oc, "accel",
535 machine_get_accel, machine_set_accel, &error_abort);
536 object_class_property_set_description(oc, "accel",
537 "Accelerator list", &error_abort);
538
539 object_class_property_add(oc, "kernel-irqchip", "on|off|split",
540 NULL, machine_set_kernel_irqchip,
541 NULL, NULL, &error_abort);
542 object_class_property_set_description(oc, "kernel-irqchip",
543 "Configure KVM in-kernel irqchip", &error_abort);
544
545 object_class_property_add(oc, "kvm-shadow-mem", "int",
546 machine_get_kvm_shadow_mem, machine_set_kvm_shadow_mem,
547 NULL, NULL, &error_abort);
548 object_class_property_set_description(oc, "kvm-shadow-mem",
549 "KVM shadow MMU size", &error_abort);
550
551 object_class_property_add_str(oc, "kernel",
552 machine_get_kernel, machine_set_kernel, &error_abort);
553 object_class_property_set_description(oc, "kernel",
554 "Linux kernel image file", &error_abort);
555
556 object_class_property_add_str(oc, "initrd",
557 machine_get_initrd, machine_set_initrd, &error_abort);
558 object_class_property_set_description(oc, "initrd",
559 "Linux initial ramdisk file", &error_abort);
560
561 object_class_property_add_str(oc, "append",
562 machine_get_append, machine_set_append, &error_abort);
563 object_class_property_set_description(oc, "append",
564 "Linux kernel command line", &error_abort);
565
566 object_class_property_add_str(oc, "dtb",
567 machine_get_dtb, machine_set_dtb, &error_abort);
568 object_class_property_set_description(oc, "dtb",
569 "Linux kernel device tree file", &error_abort);
570
571 object_class_property_add_str(oc, "dumpdtb",
572 machine_get_dumpdtb, machine_set_dumpdtb, &error_abort);
573 object_class_property_set_description(oc, "dumpdtb",
574 "Dump current dtb to a file and quit", &error_abort);
575
576 object_class_property_add(oc, "phandle-start", "int",
577 machine_get_phandle_start, machine_set_phandle_start,
578 NULL, NULL, &error_abort);
579 object_class_property_set_description(oc, "phandle-start",
580 "The first phandle ID we may generate dynamically", &error_abort);
581
582 object_class_property_add_str(oc, "dt-compatible",
583 machine_get_dt_compatible, machine_set_dt_compatible, &error_abort);
584 object_class_property_set_description(oc, "dt-compatible",
585 "Overrides the \"compatible\" property of the dt root node",
586 &error_abort);
587
588 object_class_property_add_bool(oc, "dump-guest-core",
589 machine_get_dump_guest_core, machine_set_dump_guest_core, &error_abort);
590 object_class_property_set_description(oc, "dump-guest-core",
591 "Include guest memory in a core dump", &error_abort);
592
593 object_class_property_add_bool(oc, "mem-merge",
594 machine_get_mem_merge, machine_set_mem_merge, &error_abort);
595 object_class_property_set_description(oc, "mem-merge",
596 "Enable/disable memory merge support", &error_abort);
597
598 object_class_property_add_bool(oc, "usb",
599 machine_get_usb, machine_set_usb, &error_abort);
600 object_class_property_set_description(oc, "usb",
601 "Set on/off to enable/disable usb", &error_abort);
602
603 object_class_property_add_bool(oc, "graphics",
604 machine_get_graphics, machine_set_graphics, &error_abort);
605 object_class_property_set_description(oc, "graphics",
606 "Set on/off to enable/disable graphics emulation", &error_abort);
607
608 object_class_property_add_bool(oc, "igd-passthru",
609 machine_get_igd_gfx_passthru, machine_set_igd_gfx_passthru,
610 &error_abort);
611 object_class_property_set_description(oc, "igd-passthru",
612 "Set on/off to enable/disable igd passthrou", &error_abort);
613
614 object_class_property_add_str(oc, "firmware",
615 machine_get_firmware, machine_set_firmware,
616 &error_abort);
617 object_class_property_set_description(oc, "firmware",
618 "Firmware image", &error_abort);
619
620 object_class_property_add_bool(oc, "suppress-vmdesc",
621 machine_get_suppress_vmdesc, machine_set_suppress_vmdesc,
622 &error_abort);
623 object_class_property_set_description(oc, "suppress-vmdesc",
624 "Set on to disable self-describing migration", &error_abort);
625
626 object_class_property_add_bool(oc, "enforce-config-section",
627 machine_get_enforce_config_section, machine_set_enforce_config_section,
628 &error_abort);
629 object_class_property_set_description(oc, "enforce-config-section",
630 "Set on to enforce configuration section migration", &error_abort);
631
632 object_class_property_add_str(oc, "memory-encryption",
633 machine_get_memory_encryption, machine_set_memory_encryption,
634 &error_abort);
635 object_class_property_set_description(oc, "memory-encryption",
636 "Set memory encyption object to use", &error_abort);
637}
638
639static void machine_class_base_init(ObjectClass *oc, void *data)
640{
641 if (!object_class_is_abstract(oc)) {
642 MachineClass *mc = MACHINE_CLASS(oc);
643 const char *cname = object_class_get_name(oc);
644 assert(g_str_has_suffix(cname, TYPE_MACHINE_SUFFIX));
645 mc->name = g_strndup(cname,
646 strlen(cname) - strlen(TYPE_MACHINE_SUFFIX));
647 }
648}
649
650static void machine_initfn(Object *obj)
651{
652 MachineState *ms = MACHINE(obj);
653
654 ms->kernel_irqchip_allowed = true;
655 ms->kvm_shadow_mem = -1;
656 ms->dump_guest_core = true;
657 ms->mem_merge = true;
658 ms->enable_graphics = true;
659
660
661 ms->sysbus_notifier.notify = machine_init_notify;
662 qemu_add_machine_init_done_notifier(&ms->sysbus_notifier);
663}
664
665static void machine_finalize(Object *obj)
666{
667 MachineState *ms = MACHINE(obj);
668
669 g_free(ms->accel);
670 g_free(ms->kernel_filename);
671 g_free(ms->initrd_filename);
672 g_free(ms->kernel_cmdline);
673 g_free(ms->dtb);
674 g_free(ms->dumpdtb);
675 g_free(ms->dt_compatible);
676 g_free(ms->firmware);
677 g_free(ms->device_memory);
678}
679
680bool machine_usb(MachineState *machine)
681{
682 return machine->usb;
683}
684
685bool machine_kernel_irqchip_allowed(MachineState *machine)
686{
687 return machine->kernel_irqchip_allowed;
688}
689
690bool machine_kernel_irqchip_required(MachineState *machine)
691{
692 return machine->kernel_irqchip_required;
693}
694
695bool machine_kernel_irqchip_split(MachineState *machine)
696{
697 return machine->kernel_irqchip_split;
698}
699
700int machine_kvm_shadow_mem(MachineState *machine)
701{
702 return machine->kvm_shadow_mem;
703}
704
705int machine_phandle_start(MachineState *machine)
706{
707 return machine->phandle_start;
708}
709
710bool machine_dump_guest_core(MachineState *machine)
711{
712 return machine->dump_guest_core;
713}
714
715bool machine_mem_merge(MachineState *machine)
716{
717 return machine->mem_merge;
718}
719
720static char *cpu_slot_to_string(const CPUArchId *cpu)
721{
722 GString *s = g_string_new(NULL);
723 if (cpu->props.has_socket_id) {
724 g_string_append_printf(s, "socket-id: %"PRId64, cpu->props.socket_id);
725 }
726 if (cpu->props.has_core_id) {
727 if (s->len) {
728 g_string_append_printf(s, ", ");
729 }
730 g_string_append_printf(s, "core-id: %"PRId64, cpu->props.core_id);
731 }
732 if (cpu->props.has_thread_id) {
733 if (s->len) {
734 g_string_append_printf(s, ", ");
735 }
736 g_string_append_printf(s, "thread-id: %"PRId64, cpu->props.thread_id);
737 }
738 return g_string_free(s, false);
739}
740
741static void machine_numa_finish_cpu_init(MachineState *machine)
742{
743 int i;
744 bool default_mapping;
745 GString *s = g_string_new(NULL);
746 MachineClass *mc = MACHINE_GET_CLASS(machine);
747 const CPUArchIdList *possible_cpus = mc->possible_cpu_arch_ids(machine);
748
749 assert(nb_numa_nodes);
750 for (i = 0; i < possible_cpus->len; i++) {
751 if (possible_cpus->cpus[i].props.has_node_id) {
752 break;
753 }
754 }
755 default_mapping = (i == possible_cpus->len);
756
757 for (i = 0; i < possible_cpus->len; i++) {
758 const CPUArchId *cpu_slot = &possible_cpus->cpus[i];
759
760 if (!cpu_slot->props.has_node_id) {
761
762 CpuInstanceProperties props = cpu_slot->props;
763
764 props.node_id = mc->get_default_cpu_node_id(machine, i);
765 if (!default_mapping) {
766
767
768 char *cpu_str = cpu_slot_to_string(cpu_slot);
769 g_string_append_printf(s, "%sCPU %d [%s]",
770 s->len ? ", " : "", i, cpu_str);
771 g_free(cpu_str);
772
773
774 props.node_id = 0;
775 }
776
777 props.has_node_id = true;
778 machine_set_cpu_numa_node(machine, &props, &error_fatal);
779 }
780 }
781 if (s->len && !qtest_enabled()) {
782 warn_report("CPU(s) not present in any NUMA nodes: %s",
783 s->str);
784 warn_report("All CPU(s) up to maxcpus should be described "
785 "in NUMA config, ability to start up with partial NUMA "
786 "mappings is obsoleted and will be removed in future");
787 }
788 g_string_free(s, true);
789}
790
791void machine_run_board_init(MachineState *machine)
792{
793 MachineClass *machine_class = MACHINE_GET_CLASS(machine);
794
795 numa_complete_configuration(machine);
796 if (nb_numa_nodes)
797 machine_numa_finish_cpu_init(machine);
798
799
800
801
802 if (machine_class->valid_cpu_types && machine->cpu_type) {
803 ObjectClass *class = object_class_by_name(machine->cpu_type);
804 int i;
805
806 for (i = 0; machine_class->valid_cpu_types[i]; i++) {
807 if (object_class_dynamic_cast(class,
808 machine_class->valid_cpu_types[i])) {
809
810
811
812 break;
813 }
814 }
815
816 if (!machine_class->valid_cpu_types[i]) {
817
818 error_report("Invalid CPU type: %s", machine->cpu_type);
819 error_printf("The valid types are: %s",
820 machine_class->valid_cpu_types[0]);
821 for (i = 1; machine_class->valid_cpu_types[i]; i++) {
822 error_printf(", %s", machine_class->valid_cpu_types[i]);
823 }
824 error_printf("\n");
825
826 exit(1);
827 }
828 }
829
830 machine_class->init(machine);
831}
832
833static void machine_class_finalize(ObjectClass *klass, void *data)
834{
835 MachineClass *mc = MACHINE_CLASS(klass);
836
837 if (mc->compat_props) {
838 g_array_free(mc->compat_props, true);
839 }
840 g_free(mc->name);
841}
842
843void machine_register_compat_props(MachineState *machine)
844{
845 MachineClass *mc = MACHINE_GET_CLASS(machine);
846 int i;
847 GlobalProperty *p;
848
849 if (!mc->compat_props) {
850 return;
851 }
852
853 for (i = 0; i < mc->compat_props->len; i++) {
854 p = g_array_index(mc->compat_props, GlobalProperty *, i);
855
856 p->errp = &error_abort;
857 qdev_prop_register_global(p);
858 }
859}
860
861static const TypeInfo machine_info = {
862 .name = TYPE_MACHINE,
863 .parent = TYPE_OBJECT,
864 .abstract = true,
865 .class_size = sizeof(MachineClass),
866 .class_init = machine_class_init,
867 .class_base_init = machine_class_base_init,
868 .class_finalize = machine_class_finalize,
869 .instance_size = sizeof(MachineState),
870 .instance_init = machine_initfn,
871 .instance_finalize = machine_finalize,
872};
873
874static void machine_register_types(void)
875{
876 type_register_static(&machine_info);
877}
878
879type_init(machine_register_types)
880