pcie_aer: support configurable AER capa version
[qemu.git] / hw / core / machine.c
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 static void machine_class_init(ObjectClass *oc, void *data)
361 {
362 MachineClass *mc = MACHINE_CLASS(oc);
363
364 /* Default 128 MB as guest ram size */
365 mc->default_ram_size = 128 * M_BYTE;
366 mc->rom_file_has_mr = true;
367
368 object_class_property_add_str(oc, "accel",
369 machine_get_accel, machine_set_accel, &error_abort);
370 object_class_property_set_description(oc, "accel",
371 "Accelerator list", &error_abort);
372
373 object_class_property_add(oc, "kernel-irqchip", "OnOffSplit",
374 NULL, machine_set_kernel_irqchip,
375 NULL, NULL, &error_abort);
376 object_class_property_set_description(oc, "kernel-irqchip",
377 "Configure KVM in-kernel irqchip", &error_abort);
378
379 object_class_property_add(oc, "kvm-shadow-mem", "int",
380 machine_get_kvm_shadow_mem, machine_set_kvm_shadow_mem,
381 NULL, NULL, &error_abort);
382 object_class_property_set_description(oc, "kvm-shadow-mem",
383 "KVM shadow MMU size", &error_abort);
384
385 object_class_property_add_str(oc, "kernel",
386 machine_get_kernel, machine_set_kernel, &error_abort);
387 object_class_property_set_description(oc, "kernel",
388 "Linux kernel image file", &error_abort);
389
390 object_class_property_add_str(oc, "initrd",
391 machine_get_initrd, machine_set_initrd, &error_abort);
392 object_class_property_set_description(oc, "initrd",
393 "Linux initial ramdisk file", &error_abort);
394
395 object_class_property_add_str(oc, "append",
396 machine_get_append, machine_set_append, &error_abort);
397 object_class_property_set_description(oc, "append",
398 "Linux kernel command line", &error_abort);
399
400 object_class_property_add_str(oc, "dtb",
401 machine_get_dtb, machine_set_dtb, &error_abort);
402 object_class_property_set_description(oc, "dtb",
403 "Linux kernel device tree file", &error_abort);
404
405 object_class_property_add_str(oc, "dumpdtb",
406 machine_get_dumpdtb, machine_set_dumpdtb, &error_abort);
407 object_class_property_set_description(oc, "dumpdtb",
408 "Dump current dtb to a file and quit", &error_abort);
409
410 object_class_property_add(oc, "phandle-start", "int",
411 machine_get_phandle_start, machine_set_phandle_start,
412 NULL, NULL, &error_abort);
413 object_class_property_set_description(oc, "phandle-start",
414 "The first phandle ID we may generate dynamically", &error_abort);
415
416 object_class_property_add_str(oc, "dt-compatible",
417 machine_get_dt_compatible, machine_set_dt_compatible, &error_abort);
418 object_class_property_set_description(oc, "dt-compatible",
419 "Overrides the \"compatible\" property of the dt root node",
420 &error_abort);
421
422 object_class_property_add_bool(oc, "dump-guest-core",
423 machine_get_dump_guest_core, machine_set_dump_guest_core, &error_abort);
424 object_class_property_set_description(oc, "dump-guest-core",
425 "Include guest memory in a core dump", &error_abort);
426
427 object_class_property_add_bool(oc, "mem-merge",
428 machine_get_mem_merge, machine_set_mem_merge, &error_abort);
429 object_class_property_set_description(oc, "mem-merge",
430 "Enable/disable memory merge support", &error_abort);
431
432 object_class_property_add_bool(oc, "usb",
433 machine_get_usb, machine_set_usb, &error_abort);
434 object_class_property_set_description(oc, "usb",
435 "Set on/off to enable/disable usb", &error_abort);
436
437 object_class_property_add_bool(oc, "graphics",
438 machine_get_graphics, machine_set_graphics, &error_abort);
439 object_class_property_set_description(oc, "graphics",
440 "Set on/off to enable/disable graphics emulation", &error_abort);
441
442 object_class_property_add_bool(oc, "igd-passthru",
443 machine_get_igd_gfx_passthru, machine_set_igd_gfx_passthru,
444 &error_abort);
445 object_class_property_set_description(oc, "igd-passthru",
446 "Set on/off to enable/disable igd passthrou", &error_abort);
447
448 object_class_property_add_str(oc, "firmware",
449 machine_get_firmware, machine_set_firmware,
450 &error_abort);
451 object_class_property_set_description(oc, "firmware",
452 "Firmware image", &error_abort);
453
454 object_class_property_add_bool(oc, "suppress-vmdesc",
455 machine_get_suppress_vmdesc, machine_set_suppress_vmdesc,
456 &error_abort);
457 object_class_property_set_description(oc, "suppress-vmdesc",
458 "Set on to disable self-describing migration", &error_abort);
459
460 object_class_property_add_bool(oc, "enforce-config-section",
461 machine_get_enforce_config_section, machine_set_enforce_config_section,
462 &error_abort);
463 object_class_property_set_description(oc, "enforce-config-section",
464 "Set on to enforce configuration section migration", &error_abort);
465 }
466
467 static void machine_class_base_init(ObjectClass *oc, void *data)
468 {
469 if (!object_class_is_abstract(oc)) {
470 MachineClass *mc = MACHINE_CLASS(oc);
471 const char *cname = object_class_get_name(oc);
472 assert(g_str_has_suffix(cname, TYPE_MACHINE_SUFFIX));
473 mc->name = g_strndup(cname,
474 strlen(cname) - strlen(TYPE_MACHINE_SUFFIX));
475 }
476 }
477
478 static void machine_initfn(Object *obj)
479 {
480 MachineState *ms = MACHINE(obj);
481
482 ms->kernel_irqchip_allowed = true;
483 ms->kvm_shadow_mem = -1;
484 ms->dump_guest_core = true;
485 ms->mem_merge = true;
486 ms->enable_graphics = true;
487
488 /* Register notifier when init is done for sysbus sanity checks */
489 ms->sysbus_notifier.notify = machine_init_notify;
490 qemu_add_machine_init_done_notifier(&ms->sysbus_notifier);
491 }
492
493 static void machine_finalize(Object *obj)
494 {
495 MachineState *ms = MACHINE(obj);
496
497 g_free(ms->accel);
498 g_free(ms->kernel_filename);
499 g_free(ms->initrd_filename);
500 g_free(ms->kernel_cmdline);
501 g_free(ms->dtb);
502 g_free(ms->dumpdtb);
503 g_free(ms->dt_compatible);
504 g_free(ms->firmware);
505 }
506
507 bool machine_usb(MachineState *machine)
508 {
509 return machine->usb;
510 }
511
512 bool machine_kernel_irqchip_allowed(MachineState *machine)
513 {
514 return machine->kernel_irqchip_allowed;
515 }
516
517 bool machine_kernel_irqchip_required(MachineState *machine)
518 {
519 return machine->kernel_irqchip_required;
520 }
521
522 bool machine_kernel_irqchip_split(MachineState *machine)
523 {
524 return machine->kernel_irqchip_split;
525 }
526
527 int machine_kvm_shadow_mem(MachineState *machine)
528 {
529 return machine->kvm_shadow_mem;
530 }
531
532 int machine_phandle_start(MachineState *machine)
533 {
534 return machine->phandle_start;
535 }
536
537 bool machine_dump_guest_core(MachineState *machine)
538 {
539 return machine->dump_guest_core;
540 }
541
542 bool machine_mem_merge(MachineState *machine)
543 {
544 return machine->mem_merge;
545 }
546
547 static void machine_class_finalize(ObjectClass *klass, void *data)
548 {
549 MachineClass *mc = MACHINE_CLASS(klass);
550
551 if (mc->compat_props) {
552 g_array_free(mc->compat_props, true);
553 }
554 g_free(mc->name);
555 }
556
557 void machine_register_compat_props(MachineState *machine)
558 {
559 MachineClass *mc = MACHINE_GET_CLASS(machine);
560 int i;
561 GlobalProperty *p;
562
563 if (!mc->compat_props) {
564 return;
565 }
566
567 for (i = 0; i < mc->compat_props->len; i++) {
568 p = g_array_index(mc->compat_props, GlobalProperty *, i);
569 /* Machine compat_props must never cause errors: */
570 p->errp = &error_abort;
571 qdev_prop_register_global(p);
572 }
573 }
574
575 static const TypeInfo machine_info = {
576 .name = TYPE_MACHINE,
577 .parent = TYPE_OBJECT,
578 .abstract = true,
579 .class_size = sizeof(MachineClass),
580 .class_init = machine_class_init,
581 .class_base_init = machine_class_base_init,
582 .class_finalize = machine_class_finalize,
583 .instance_size = sizeof(MachineState),
584 .instance_init = machine_initfn,
585 .instance_finalize = machine_finalize,
586 };
587
588 static void machine_register_types(void)
589 {
590 type_register_static(&machine_info);
591 }
592
593 type_init(machine_register_types)