xref: /qemu/hw/core/machine.c (revision a6c76285) 
1 /*
2  * QEMU Machine
3  *
4  * Copyright (C) 2014 Red Hat Inc
5  *
6  * Authors:
7  *   Marcel Apfelbaum <marcel.a@redhat.com>
8  *
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.
11  */
12 
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"
22 
23 static char *machine_get_accel(Object *obj, Error **errp)
24 {
25     MachineState *ms = MACHINE(obj);
26 
27     return g_strdup(ms->accel);
28 }
29 
30 static void machine_set_accel(Object *obj, const char *value, Error **errp)
31 {
32     MachineState *ms = MACHINE(obj);
33 
34     g_free(ms->accel);
35     ms->accel = g_strdup(value);
36 }
37 
38 static void machine_set_kernel_irqchip(Object *obj, Visitor *v,
39                                        const char *name, void *opaque,
40                                        Error **errp)
41 {
42     Error *err = NULL;
43     MachineState *ms = MACHINE(obj);
44     OnOffSplit mode;
45 
46     visit_type_OnOffSplit(v, name, &mode, &err);
47     if (err) {
48         error_propagate(errp, err);
49         return;
50     } else {
51         switch (mode) {
52         case ON_OFF_SPLIT_ON:
53             ms->kernel_irqchip_allowed = true;
54             ms->kernel_irqchip_required = true;
55             ms->kernel_irqchip_split = false;
56             break;
57         case ON_OFF_SPLIT_OFF:
58             ms->kernel_irqchip_allowed = false;
59             ms->kernel_irqchip_required = false;
60             ms->kernel_irqchip_split = false;
61             break;
62         case ON_OFF_SPLIT_SPLIT:
63             ms->kernel_irqchip_allowed = true;
64             ms->kernel_irqchip_required = true;
65             ms->kernel_irqchip_split = true;
66             break;
67         default:
68             /* The value was checked in visit_type_OnOffSplit() above. If
69              * we get here, then something is wrong in QEMU.
70              */
71             abort();
72         }
73     }
74 }
75 
76 static void machine_get_kvm_shadow_mem(Object *obj, Visitor *v,
77                                        const char *name, void *opaque,
78                                        Error **errp)
79 {
80     MachineState *ms = MACHINE(obj);
81     int64_t value = ms->kvm_shadow_mem;
82 
83     visit_type_int(v, name, &value, errp);
84 }
85 
86 static void machine_set_kvm_shadow_mem(Object *obj, Visitor *v,
87                                        const char *name, void *opaque,
88                                        Error **errp)
89 {
90     MachineState *ms = MACHINE(obj);
91     Error *error = NULL;
92     int64_t value;
93 
94     visit_type_int(v, name, &value, &error);
95     if (error) {
96         error_propagate(errp, error);
97         return;
98     }
99 
100     ms->kvm_shadow_mem = value;
101 }
102 
103 static char *machine_get_kernel(Object *obj, Error **errp)
104 {
105     MachineState *ms = MACHINE(obj);
106 
107     return g_strdup(ms->kernel_filename);
108 }
109 
110 static void machine_set_kernel(Object *obj, const char *value, Error **errp)
111 {
112     MachineState *ms = MACHINE(obj);
113 
114     g_free(ms->kernel_filename);
115     ms->kernel_filename = g_strdup(value);
116 }
117 
118 static char *machine_get_initrd(Object *obj, Error **errp)
119 {
120     MachineState *ms = MACHINE(obj);
121 
122     return g_strdup(ms->initrd_filename);
123 }
124 
125 static void machine_set_initrd(Object *obj, const char *value, Error **errp)
126 {
127     MachineState *ms = MACHINE(obj);
128 
129     g_free(ms->initrd_filename);
130     ms->initrd_filename = g_strdup(value);
131 }
132 
133 static char *machine_get_append(Object *obj, Error **errp)
134 {
135     MachineState *ms = MACHINE(obj);
136 
137     return g_strdup(ms->kernel_cmdline);
138 }
139 
140 static void machine_set_append(Object *obj, const char *value, Error **errp)
141 {
142     MachineState *ms = MACHINE(obj);
143 
144     g_free(ms->kernel_cmdline);
145     ms->kernel_cmdline = g_strdup(value);
146 }
147 
148 static char *machine_get_dtb(Object *obj, Error **errp)
149 {
150     MachineState *ms = MACHINE(obj);
151 
152     return g_strdup(ms->dtb);
153 }
154 
155 static void machine_set_dtb(Object *obj, const char *value, Error **errp)
156 {
157     MachineState *ms = MACHINE(obj);
158 
159     g_free(ms->dtb);
160     ms->dtb = g_strdup(value);
161 }
162 
163 static char *machine_get_dumpdtb(Object *obj, Error **errp)
164 {
165     MachineState *ms = MACHINE(obj);
166 
167     return g_strdup(ms->dumpdtb);
168 }
169 
170 static void machine_set_dumpdtb(Object *obj, const char *value, Error **errp)
171 {
172     MachineState *ms = MACHINE(obj);
173 
174     g_free(ms->dumpdtb);
175     ms->dumpdtb = g_strdup(value);
176 }
177 
178 static void machine_get_phandle_start(Object *obj, Visitor *v,
179                                       const char *name, void *opaque,
180                                       Error **errp)
181 {
182     MachineState *ms = MACHINE(obj);
183     int64_t value = ms->phandle_start;
184 
185     visit_type_int(v, name, &value, errp);
186 }
187 
188 static void machine_set_phandle_start(Object *obj, Visitor *v,
189                                       const char *name, void *opaque,
190                                       Error **errp)
191 {
192     MachineState *ms = MACHINE(obj);
193     Error *error = NULL;
194     int64_t value;
195 
196     visit_type_int(v, name, &value, &error);
197     if (error) {
198         error_propagate(errp, error);
199         return;
200     }
201 
202     ms->phandle_start = value;
203 }
204 
205 static char *machine_get_dt_compatible(Object *obj, Error **errp)
206 {
207     MachineState *ms = MACHINE(obj);
208 
209     return g_strdup(ms->dt_compatible);
210 }
211 
212 static void machine_set_dt_compatible(Object *obj, const char *value, Error **errp)
213 {
214     MachineState *ms = MACHINE(obj);
215 
216     g_free(ms->dt_compatible);
217     ms->dt_compatible = g_strdup(value);
218 }
219 
220 static bool machine_get_dump_guest_core(Object *obj, Error **errp)
221 {
222     MachineState *ms = MACHINE(obj);
223 
224     return ms->dump_guest_core;
225 }
226 
227 static void machine_set_dump_guest_core(Object *obj, bool value, Error **errp)
228 {
229     MachineState *ms = MACHINE(obj);
230 
231     ms->dump_guest_core = value;
232 }
233 
234 static bool machine_get_mem_merge(Object *obj, Error **errp)
235 {
236     MachineState *ms = MACHINE(obj);
237 
238     return ms->mem_merge;
239 }
240 
241 static void machine_set_mem_merge(Object *obj, bool value, Error **errp)
242 {
243     MachineState *ms = MACHINE(obj);
244 
245     ms->mem_merge = value;
246 }
247 
248 static bool machine_get_usb(Object *obj, Error **errp)
249 {
250     MachineState *ms = MACHINE(obj);
251 
252     return ms->usb;
253 }
254 
255 static void machine_set_usb(Object *obj, bool value, Error **errp)
256 {
257     MachineState *ms = MACHINE(obj);
258 
259     ms->usb = value;
260     ms->usb_disabled = !value;
261 }
262 
263 static bool machine_get_graphics(Object *obj, Error **errp)
264 {
265     MachineState *ms = MACHINE(obj);
266 
267     return ms->enable_graphics;
268 }
269 
270 static void machine_set_graphics(Object *obj, bool value, Error **errp)
271 {
272     MachineState *ms = MACHINE(obj);
273 
274     ms->enable_graphics = value;
275 }
276 
277 static bool machine_get_igd_gfx_passthru(Object *obj, Error **errp)
278 {
279     MachineState *ms = MACHINE(obj);
280 
281     return ms->igd_gfx_passthru;
282 }
283 
284 static void machine_set_igd_gfx_passthru(Object *obj, bool value, Error **errp)
285 {
286     MachineState *ms = MACHINE(obj);
287 
288     ms->igd_gfx_passthru = value;
289 }
290 
291 static char *machine_get_firmware(Object *obj, Error **errp)
292 {
293     MachineState *ms = MACHINE(obj);
294 
295     return g_strdup(ms->firmware);
296 }
297 
298 static void machine_set_firmware(Object *obj, const char *value, Error **errp)
299 {
300     MachineState *ms = MACHINE(obj);
301 
302     g_free(ms->firmware);
303     ms->firmware = g_strdup(value);
304 }
305 
306 static void machine_set_suppress_vmdesc(Object *obj, bool value, Error **errp)
307 {
308     MachineState *ms = MACHINE(obj);
309 
310     ms->suppress_vmdesc = value;
311 }
312 
313 static bool machine_get_suppress_vmdesc(Object *obj, Error **errp)
314 {
315     MachineState *ms = MACHINE(obj);
316 
317     return ms->suppress_vmdesc;
318 }
319 
320 static void machine_set_enforce_config_section(Object *obj, bool value,
321                                              Error **errp)
322 {
323     MachineState *ms = MACHINE(obj);
324 
325     ms->enforce_config_section = value;
326 }
327 
328 static bool machine_get_enforce_config_section(Object *obj, Error **errp)
329 {
330     MachineState *ms = MACHINE(obj);
331 
332     return ms->enforce_config_section;
333 }
334 
335 static void error_on_sysbus_device(SysBusDevice *sbdev, void *opaque)
336 {
337     error_report("Option '-device %s' cannot be handled by this machine",
338                  object_class_get_name(object_get_class(OBJECT(sbdev))));
339     exit(1);
340 }
341 
342 static void machine_init_notify(Notifier *notifier, void *data)
343 {
344     Object *machine = qdev_get_machine();
345     ObjectClass *oc = object_get_class(machine);
346     MachineClass *mc = MACHINE_CLASS(oc);
347 
348     if (mc->has_dynamic_sysbus) {
349         /* Our machine can handle dynamic sysbus devices, we're all good */
350         return;
351     }
352 
353     /*
354      * Loop through all dynamically created devices and check whether there
355      * are sysbus devices among them. If there are, error out.
356      */
357     foreach_dynamic_sysbus_device(error_on_sysbus_device, NULL);
358 }
359 
360 HotpluggableCPUList *machine_query_hotpluggable_cpus(MachineState *machine)
361 {
362     int i;
363     Object *cpu;
364     HotpluggableCPUList *head = NULL;
365     const char *cpu_type;
366 
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);
373 
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));
378 
379         cpu = machine->possible_cpus->cpus[i].cpu;
380         if (cpu) {
381             cpu_item->has_qom_path = true;
382             cpu_item->qom_path = object_get_canonical_path(cpu);
383         }
384         list_item->value = cpu_item;
385         list_item->next = head;
386         head = list_item;
387     }
388     return head;
389 }
390 
391 static void machine_class_init(ObjectClass *oc, void *data)
392 {
393     MachineClass *mc = MACHINE_CLASS(oc);
394 
395     /* Default 128 MB as guest ram size */
396     mc->default_ram_size = 128 * M_BYTE;
397     mc->rom_file_has_mr = true;
398 
399     /* numa node memory size aligned on 8MB by default.
400      * On Linux, each node's border has to be 8MB aligned
401      */
402     mc->numa_mem_align_shift = 23;
403 
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);
408 
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);
414 
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);
420 
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);
425 
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);
430 
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);
435 
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);
440 
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);
445 
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);
451 
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",
456         &error_abort);
457 
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);
462 
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);
467 
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);
472 
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);
477 
478     object_class_property_add_bool(oc, "igd-passthru",
479         machine_get_igd_gfx_passthru, machine_set_igd_gfx_passthru,
480         &error_abort);
481     object_class_property_set_description(oc, "igd-passthru",
482         "Set on/off to enable/disable igd passthrou", &error_abort);
483 
484     object_class_property_add_str(oc, "firmware",
485         machine_get_firmware, machine_set_firmware,
486         &error_abort);
487     object_class_property_set_description(oc, "firmware",
488         "Firmware image", &error_abort);
489 
490     object_class_property_add_bool(oc, "suppress-vmdesc",
491         machine_get_suppress_vmdesc, machine_set_suppress_vmdesc,
492         &error_abort);
493     object_class_property_set_description(oc, "suppress-vmdesc",
494         "Set on to disable self-describing migration", &error_abort);
495 
496     object_class_property_add_bool(oc, "enforce-config-section",
497         machine_get_enforce_config_section, machine_set_enforce_config_section,
498         &error_abort);
499     object_class_property_set_description(oc, "enforce-config-section",
500         "Set on to enforce configuration section migration", &error_abort);
501 }
502 
503 static void machine_class_base_init(ObjectClass *oc, void *data)
504 {
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));
511     }
512 }
513 
514 static void machine_initfn(Object *obj)
515 {
516     MachineState *ms = MACHINE(obj);
517 
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;
523 
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);
527 }
528 
529 static void machine_finalize(Object *obj)
530 {
531     MachineState *ms = MACHINE(obj);
532 
533     g_free(ms->accel);
534     g_free(ms->kernel_filename);
535     g_free(ms->initrd_filename);
536     g_free(ms->kernel_cmdline);
537     g_free(ms->dtb);
538     g_free(ms->dumpdtb);
539     g_free(ms->dt_compatible);
540     g_free(ms->firmware);
541 }
542 
543 bool machine_usb(MachineState *machine)
544 {
545     return machine->usb;
546 }
547 
548 bool machine_kernel_irqchip_allowed(MachineState *machine)
549 {
550     return machine->kernel_irqchip_allowed;
551 }
552 
553 bool machine_kernel_irqchip_required(MachineState *machine)
554 {
555     return machine->kernel_irqchip_required;
556 }
557 
558 bool machine_kernel_irqchip_split(MachineState *machine)
559 {
560     return machine->kernel_irqchip_split;
561 }
562 
563 int machine_kvm_shadow_mem(MachineState *machine)
564 {
565     return machine->kvm_shadow_mem;
566 }
567 
568 int machine_phandle_start(MachineState *machine)
569 {
570     return machine->phandle_start;
571 }
572 
573 bool machine_dump_guest_core(MachineState *machine)
574 {
575     return machine->dump_guest_core;
576 }
577 
578 bool machine_mem_merge(MachineState *machine)
579 {
580     return machine->mem_merge;
581 }
582 
583 static void machine_class_finalize(ObjectClass *klass, void *data)
584 {
585     MachineClass *mc = MACHINE_CLASS(klass);
586 
587     if (mc->compat_props) {
588         g_array_free(mc->compat_props, true);
589     }
590     g_free(mc->name);
591 }
592 
593 static void register_compat_prop(const char *driver,
594                                  const char *property,
595                                  const char *value)
596 {
597     GlobalProperty *p = g_new0(GlobalProperty, 1);
598     /* Machine compat_props must never cause errors: */
599     p->errp = &error_abort;
600     p->driver = driver;
601     p->property = property;
602     p->value = value;
603     qdev_prop_register_global(p);
604 }
605 
606 static void machine_register_compat_for_subclass(ObjectClass *oc, void *opaque)
607 {
608     GlobalProperty *p = opaque;
609     register_compat_prop(object_class_get_name(oc), p->property, p->value);
610 }
611 
612 void machine_register_compat_props(MachineState *machine)
613 {
614     MachineClass *mc = MACHINE_GET_CLASS(machine);
615     int i;
616     GlobalProperty *p;
617     ObjectClass *oc;
618 
619     if (!mc->compat_props) {
620         return;
621     }
622 
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.
631              *
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.
635              */
636             object_class_foreach(machine_register_compat_for_subclass,
637                                  p->driver, false, p);
638         } else {
639             register_compat_prop(p->driver, p->property, p->value);
640         }
641     }
642 }
643 
644 static const TypeInfo machine_info = {
645     .name = TYPE_MACHINE,
646     .parent = TYPE_OBJECT,
647     .abstract = true,
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,
655 };
656 
657 static void machine_register_types(void)
658 {
659     type_register_static(&machine_info);
660 }
661 
662 type_init(machine_register_types)
663