i386/cpu: Consolidate die-id validity in smp context
[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 "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 #include "hw/pci/pci.h"
25 #include "hw/mem/nvdimm.h"
26
27 GlobalProperty hw_compat_4_0[] = {
28 { "VGA", "edid", "false" },
29 { "secondary-vga", "edid", "false" },
30 { "bochs-display", "edid", "false" },
31 { "virtio-vga", "edid", "false" },
32 { "virtio-gpu-pci", "edid", "false" },
33 { "virtio-device", "use-started", "false" },
34 };
35 const size_t hw_compat_4_0_len = G_N_ELEMENTS(hw_compat_4_0);
36
37 GlobalProperty hw_compat_3_1[] = {
38 { "pcie-root-port", "x-speed", "2_5" },
39 { "pcie-root-port", "x-width", "1" },
40 { "memory-backend-file", "x-use-canonical-path-for-ramblock-id", "true" },
41 { "memory-backend-memfd", "x-use-canonical-path-for-ramblock-id", "true" },
42 { "tpm-crb", "ppi", "false" },
43 { "tpm-tis", "ppi", "false" },
44 { "usb-kbd", "serial", "42" },
45 { "usb-mouse", "serial", "42" },
46 { "usb-tablet", "serial", "42" },
47 { "virtio-blk-device", "discard", "false" },
48 { "virtio-blk-device", "write-zeroes", "false" },
49 };
50 const size_t hw_compat_3_1_len = G_N_ELEMENTS(hw_compat_3_1);
51
52 GlobalProperty hw_compat_3_0[] = {};
53 const size_t hw_compat_3_0_len = G_N_ELEMENTS(hw_compat_3_0);
54
55 GlobalProperty hw_compat_2_12[] = {
56 { "migration", "decompress-error-check", "off" },
57 { "hda-audio", "use-timer", "false" },
58 { "cirrus-vga", "global-vmstate", "true" },
59 { "VGA", "global-vmstate", "true" },
60 { "vmware-svga", "global-vmstate", "true" },
61 { "qxl-vga", "global-vmstate", "true" },
62 };
63 const size_t hw_compat_2_12_len = G_N_ELEMENTS(hw_compat_2_12);
64
65 GlobalProperty hw_compat_2_11[] = {
66 { "hpet", "hpet-offset-saved", "false" },
67 { "virtio-blk-pci", "vectors", "2" },
68 { "vhost-user-blk-pci", "vectors", "2" },
69 { "e1000", "migrate_tso_props", "off" },
70 };
71 const size_t hw_compat_2_11_len = G_N_ELEMENTS(hw_compat_2_11);
72
73 GlobalProperty hw_compat_2_10[] = {
74 { "virtio-mouse-device", "wheel-axis", "false" },
75 { "virtio-tablet-device", "wheel-axis", "false" },
76 };
77 const size_t hw_compat_2_10_len = G_N_ELEMENTS(hw_compat_2_10);
78
79 GlobalProperty hw_compat_2_9[] = {
80 { "pci-bridge", "shpc", "off" },
81 { "intel-iommu", "pt", "off" },
82 { "virtio-net-device", "x-mtu-bypass-backend", "off" },
83 { "pcie-root-port", "x-migrate-msix", "false" },
84 };
85 const size_t hw_compat_2_9_len = G_N_ELEMENTS(hw_compat_2_9);
86
87 GlobalProperty hw_compat_2_8[] = {
88 { "fw_cfg_mem", "x-file-slots", "0x10" },
89 { "fw_cfg_io", "x-file-slots", "0x10" },
90 { "pflash_cfi01", "old-multiple-chip-handling", "on" },
91 { "pci-bridge", "shpc", "on" },
92 { TYPE_PCI_DEVICE, "x-pcie-extcap-init", "off" },
93 { "virtio-pci", "x-pcie-deverr-init", "off" },
94 { "virtio-pci", "x-pcie-lnkctl-init", "off" },
95 { "virtio-pci", "x-pcie-pm-init", "off" },
96 { "cirrus-vga", "vgamem_mb", "8" },
97 { "isa-cirrus-vga", "vgamem_mb", "8" },
98 };
99 const size_t hw_compat_2_8_len = G_N_ELEMENTS(hw_compat_2_8);
100
101 GlobalProperty hw_compat_2_7[] = {
102 { "virtio-pci", "page-per-vq", "on" },
103 { "virtio-serial-device", "emergency-write", "off" },
104 { "ioapic", "version", "0x11" },
105 { "intel-iommu", "x-buggy-eim", "true" },
106 { "virtio-pci", "x-ignore-backend-features", "on" },
107 };
108 const size_t hw_compat_2_7_len = G_N_ELEMENTS(hw_compat_2_7);
109
110 GlobalProperty hw_compat_2_6[] = {
111 { "virtio-mmio", "format_transport_address", "off" },
112 /*
113 * don't include devices which are modern-only
114 * ie keyboard, mouse, tablet, gpu, vga & crypto
115 */
116 { "virtio-9p-pci", "disable-modern", "on" },
117 { "virtio-9p-pci", "disable-legacy", "off" },
118 { "virtio-balloon-pci", "disable-modern", "on" },
119 { "virtio-balloon-pci", "disable-legacy", "off" },
120 { "virtio-blk-pci", "disable-modern", "on" },
121 { "virtio-blk-pci", "disable-legacy", "off" },
122 { "virtio-input-host-pci", "disable-modern", "on" },
123 { "virtio-input-host-pci", "disable-legacy", "off" },
124 { "virtio-net-pci", "disable-modern", "on" },
125 { "virtio-net-pci", "disable-legacy", "off" },
126 { "virtio-rng-pci", "disable-modern", "on" },
127 { "virtio-rng-pci", "disable-legacy", "off" },
128 { "virtio-scsi-pci", "disable-modern", "on" },
129 { "virtio-scsi-pci", "disable-legacy", "off" },
130 { "virtio-serial-pci", "disable-modern", "on" },
131 { "virtio-serial-pci", "disable-legacy", "off" },
132 };
133 const size_t hw_compat_2_6_len = G_N_ELEMENTS(hw_compat_2_6);
134
135 GlobalProperty hw_compat_2_5[] = {
136 { "isa-fdc", "fallback", "144" },
137 { "pvscsi", "x-old-pci-configuration", "on" },
138 { "pvscsi", "x-disable-pcie", "on" },
139 { "vmxnet3", "x-old-msi-offsets", "on" },
140 { "vmxnet3", "x-disable-pcie", "on" },
141 };
142 const size_t hw_compat_2_5_len = G_N_ELEMENTS(hw_compat_2_5);
143
144 GlobalProperty hw_compat_2_4[] = {
145 { "virtio-blk-device", "scsi", "true" },
146 { "e1000", "extra_mac_registers", "off" },
147 { "virtio-pci", "x-disable-pcie", "on" },
148 { "virtio-pci", "migrate-extra", "off" },
149 { "fw_cfg_mem", "dma_enabled", "off" },
150 { "fw_cfg_io", "dma_enabled", "off" }
151 };
152 const size_t hw_compat_2_4_len = G_N_ELEMENTS(hw_compat_2_4);
153
154 GlobalProperty hw_compat_2_3[] = {
155 { "virtio-blk-pci", "any_layout", "off" },
156 { "virtio-balloon-pci", "any_layout", "off" },
157 { "virtio-serial-pci", "any_layout", "off" },
158 { "virtio-9p-pci", "any_layout", "off" },
159 { "virtio-rng-pci", "any_layout", "off" },
160 { TYPE_PCI_DEVICE, "x-pcie-lnksta-dllla", "off" },
161 { "migration", "send-configuration", "off" },
162 { "migration", "send-section-footer", "off" },
163 { "migration", "store-global-state", "off" },
164 };
165 const size_t hw_compat_2_3_len = G_N_ELEMENTS(hw_compat_2_3);
166
167 GlobalProperty hw_compat_2_2[] = {};
168 const size_t hw_compat_2_2_len = G_N_ELEMENTS(hw_compat_2_2);
169
170 GlobalProperty hw_compat_2_1[] = {
171 { "intel-hda", "old_msi_addr", "on" },
172 { "VGA", "qemu-extended-regs", "off" },
173 { "secondary-vga", "qemu-extended-regs", "off" },
174 { "virtio-scsi-pci", "any_layout", "off" },
175 { "usb-mouse", "usb_version", "1" },
176 { "usb-kbd", "usb_version", "1" },
177 { "virtio-pci", "virtio-pci-bus-master-bug-migration", "on" },
178 };
179 const size_t hw_compat_2_1_len = G_N_ELEMENTS(hw_compat_2_1);
180
181 static char *machine_get_accel(Object *obj, Error **errp)
182 {
183 MachineState *ms = MACHINE(obj);
184
185 return g_strdup(ms->accel);
186 }
187
188 static void machine_set_accel(Object *obj, const char *value, Error **errp)
189 {
190 MachineState *ms = MACHINE(obj);
191
192 g_free(ms->accel);
193 ms->accel = g_strdup(value);
194 }
195
196 static void machine_set_kernel_irqchip(Object *obj, Visitor *v,
197 const char *name, void *opaque,
198 Error **errp)
199 {
200 Error *err = NULL;
201 MachineState *ms = MACHINE(obj);
202 OnOffSplit mode;
203
204 visit_type_OnOffSplit(v, name, &mode, &err);
205 if (err) {
206 error_propagate(errp, err);
207 return;
208 } else {
209 switch (mode) {
210 case ON_OFF_SPLIT_ON:
211 ms->kernel_irqchip_allowed = true;
212 ms->kernel_irqchip_required = true;
213 ms->kernel_irqchip_split = false;
214 break;
215 case ON_OFF_SPLIT_OFF:
216 ms->kernel_irqchip_allowed = false;
217 ms->kernel_irqchip_required = false;
218 ms->kernel_irqchip_split = false;
219 break;
220 case ON_OFF_SPLIT_SPLIT:
221 ms->kernel_irqchip_allowed = true;
222 ms->kernel_irqchip_required = true;
223 ms->kernel_irqchip_split = true;
224 break;
225 default:
226 /* The value was checked in visit_type_OnOffSplit() above. If
227 * we get here, then something is wrong in QEMU.
228 */
229 abort();
230 }
231 }
232 }
233
234 static void machine_get_kvm_shadow_mem(Object *obj, Visitor *v,
235 const char *name, void *opaque,
236 Error **errp)
237 {
238 MachineState *ms = MACHINE(obj);
239 int64_t value = ms->kvm_shadow_mem;
240
241 visit_type_int(v, name, &value, errp);
242 }
243
244 static void machine_set_kvm_shadow_mem(Object *obj, Visitor *v,
245 const char *name, void *opaque,
246 Error **errp)
247 {
248 MachineState *ms = MACHINE(obj);
249 Error *error = NULL;
250 int64_t value;
251
252 visit_type_int(v, name, &value, &error);
253 if (error) {
254 error_propagate(errp, error);
255 return;
256 }
257
258 ms->kvm_shadow_mem = value;
259 }
260
261 static char *machine_get_kernel(Object *obj, Error **errp)
262 {
263 MachineState *ms = MACHINE(obj);
264
265 return g_strdup(ms->kernel_filename);
266 }
267
268 static void machine_set_kernel(Object *obj, const char *value, Error **errp)
269 {
270 MachineState *ms = MACHINE(obj);
271
272 g_free(ms->kernel_filename);
273 ms->kernel_filename = g_strdup(value);
274 }
275
276 static char *machine_get_initrd(Object *obj, Error **errp)
277 {
278 MachineState *ms = MACHINE(obj);
279
280 return g_strdup(ms->initrd_filename);
281 }
282
283 static void machine_set_initrd(Object *obj, const char *value, Error **errp)
284 {
285 MachineState *ms = MACHINE(obj);
286
287 g_free(ms->initrd_filename);
288 ms->initrd_filename = g_strdup(value);
289 }
290
291 static char *machine_get_append(Object *obj, Error **errp)
292 {
293 MachineState *ms = MACHINE(obj);
294
295 return g_strdup(ms->kernel_cmdline);
296 }
297
298 static void machine_set_append(Object *obj, const char *value, Error **errp)
299 {
300 MachineState *ms = MACHINE(obj);
301
302 g_free(ms->kernel_cmdline);
303 ms->kernel_cmdline = g_strdup(value);
304 }
305
306 static char *machine_get_dtb(Object *obj, Error **errp)
307 {
308 MachineState *ms = MACHINE(obj);
309
310 return g_strdup(ms->dtb);
311 }
312
313 static void machine_set_dtb(Object *obj, const char *value, Error **errp)
314 {
315 MachineState *ms = MACHINE(obj);
316
317 g_free(ms->dtb);
318 ms->dtb = g_strdup(value);
319 }
320
321 static char *machine_get_dumpdtb(Object *obj, Error **errp)
322 {
323 MachineState *ms = MACHINE(obj);
324
325 return g_strdup(ms->dumpdtb);
326 }
327
328 static void machine_set_dumpdtb(Object *obj, const char *value, Error **errp)
329 {
330 MachineState *ms = MACHINE(obj);
331
332 g_free(ms->dumpdtb);
333 ms->dumpdtb = g_strdup(value);
334 }
335
336 static void machine_get_phandle_start(Object *obj, Visitor *v,
337 const char *name, void *opaque,
338 Error **errp)
339 {
340 MachineState *ms = MACHINE(obj);
341 int64_t value = ms->phandle_start;
342
343 visit_type_int(v, name, &value, errp);
344 }
345
346 static void machine_set_phandle_start(Object *obj, Visitor *v,
347 const char *name, void *opaque,
348 Error **errp)
349 {
350 MachineState *ms = MACHINE(obj);
351 Error *error = NULL;
352 int64_t value;
353
354 visit_type_int(v, name, &value, &error);
355 if (error) {
356 error_propagate(errp, error);
357 return;
358 }
359
360 ms->phandle_start = value;
361 }
362
363 static char *machine_get_dt_compatible(Object *obj, Error **errp)
364 {
365 MachineState *ms = MACHINE(obj);
366
367 return g_strdup(ms->dt_compatible);
368 }
369
370 static void machine_set_dt_compatible(Object *obj, const char *value, Error **errp)
371 {
372 MachineState *ms = MACHINE(obj);
373
374 g_free(ms->dt_compatible);
375 ms->dt_compatible = g_strdup(value);
376 }
377
378 static bool machine_get_dump_guest_core(Object *obj, Error **errp)
379 {
380 MachineState *ms = MACHINE(obj);
381
382 return ms->dump_guest_core;
383 }
384
385 static void machine_set_dump_guest_core(Object *obj, bool value, Error **errp)
386 {
387 MachineState *ms = MACHINE(obj);
388
389 ms->dump_guest_core = value;
390 }
391
392 static bool machine_get_mem_merge(Object *obj, Error **errp)
393 {
394 MachineState *ms = MACHINE(obj);
395
396 return ms->mem_merge;
397 }
398
399 static void machine_set_mem_merge(Object *obj, bool value, Error **errp)
400 {
401 MachineState *ms = MACHINE(obj);
402
403 ms->mem_merge = value;
404 }
405
406 static bool machine_get_usb(Object *obj, Error **errp)
407 {
408 MachineState *ms = MACHINE(obj);
409
410 return ms->usb;
411 }
412
413 static void machine_set_usb(Object *obj, bool value, Error **errp)
414 {
415 MachineState *ms = MACHINE(obj);
416
417 ms->usb = value;
418 ms->usb_disabled = !value;
419 }
420
421 static bool machine_get_graphics(Object *obj, Error **errp)
422 {
423 MachineState *ms = MACHINE(obj);
424
425 return ms->enable_graphics;
426 }
427
428 static void machine_set_graphics(Object *obj, bool value, Error **errp)
429 {
430 MachineState *ms = MACHINE(obj);
431
432 ms->enable_graphics = value;
433 }
434
435 static bool machine_get_igd_gfx_passthru(Object *obj, Error **errp)
436 {
437 MachineState *ms = MACHINE(obj);
438
439 return ms->igd_gfx_passthru;
440 }
441
442 static void machine_set_igd_gfx_passthru(Object *obj, bool value, Error **errp)
443 {
444 MachineState *ms = MACHINE(obj);
445
446 ms->igd_gfx_passthru = value;
447 }
448
449 static char *machine_get_firmware(Object *obj, Error **errp)
450 {
451 MachineState *ms = MACHINE(obj);
452
453 return g_strdup(ms->firmware);
454 }
455
456 static void machine_set_firmware(Object *obj, const char *value, Error **errp)
457 {
458 MachineState *ms = MACHINE(obj);
459
460 g_free(ms->firmware);
461 ms->firmware = g_strdup(value);
462 }
463
464 static void machine_set_suppress_vmdesc(Object *obj, bool value, Error **errp)
465 {
466 MachineState *ms = MACHINE(obj);
467
468 ms->suppress_vmdesc = value;
469 }
470
471 static bool machine_get_suppress_vmdesc(Object *obj, Error **errp)
472 {
473 MachineState *ms = MACHINE(obj);
474
475 return ms->suppress_vmdesc;
476 }
477
478 static void machine_set_enforce_config_section(Object *obj, bool value,
479 Error **errp)
480 {
481 MachineState *ms = MACHINE(obj);
482
483 warn_report("enforce-config-section is deprecated, please use "
484 "-global migration.send-configuration=on|off instead");
485
486 ms->enforce_config_section = value;
487 }
488
489 static bool machine_get_enforce_config_section(Object *obj, Error **errp)
490 {
491 MachineState *ms = MACHINE(obj);
492
493 return ms->enforce_config_section;
494 }
495
496 static char *machine_get_memory_encryption(Object *obj, Error **errp)
497 {
498 MachineState *ms = MACHINE(obj);
499
500 return g_strdup(ms->memory_encryption);
501 }
502
503 static void machine_set_memory_encryption(Object *obj, const char *value,
504 Error **errp)
505 {
506 MachineState *ms = MACHINE(obj);
507
508 g_free(ms->memory_encryption);
509 ms->memory_encryption = g_strdup(value);
510 }
511
512 static bool machine_get_nvdimm(Object *obj, Error **errp)
513 {
514 MachineState *ms = MACHINE(obj);
515
516 return ms->nvdimms_state->is_enabled;
517 }
518
519 static void machine_set_nvdimm(Object *obj, bool value, Error **errp)
520 {
521 MachineState *ms = MACHINE(obj);
522
523 ms->nvdimms_state->is_enabled = value;
524 }
525
526 static char *machine_get_nvdimm_persistence(Object *obj, Error **errp)
527 {
528 MachineState *ms = MACHINE(obj);
529
530 return g_strdup(ms->nvdimms_state->persistence_string);
531 }
532
533 static void machine_set_nvdimm_persistence(Object *obj, const char *value,
534 Error **errp)
535 {
536 MachineState *ms = MACHINE(obj);
537 NVDIMMState *nvdimms_state = ms->nvdimms_state;
538
539 if (strcmp(value, "cpu") == 0) {
540 nvdimms_state->persistence = 3;
541 } else if (strcmp(value, "mem-ctrl") == 0) {
542 nvdimms_state->persistence = 2;
543 } else {
544 error_setg(errp, "-machine nvdimm-persistence=%s: unsupported option",
545 value);
546 return;
547 }
548
549 g_free(nvdimms_state->persistence_string);
550 nvdimms_state->persistence_string = g_strdup(value);
551 }
552
553 void machine_class_allow_dynamic_sysbus_dev(MachineClass *mc, const char *type)
554 {
555 strList *item = g_new0(strList, 1);
556
557 item->value = g_strdup(type);
558 item->next = mc->allowed_dynamic_sysbus_devices;
559 mc->allowed_dynamic_sysbus_devices = item;
560 }
561
562 static void validate_sysbus_device(SysBusDevice *sbdev, void *opaque)
563 {
564 MachineState *machine = opaque;
565 MachineClass *mc = MACHINE_GET_CLASS(machine);
566 bool allowed = false;
567 strList *wl;
568
569 for (wl = mc->allowed_dynamic_sysbus_devices;
570 !allowed && wl;
571 wl = wl->next) {
572 allowed |= !!object_dynamic_cast(OBJECT(sbdev), wl->value);
573 }
574
575 if (!allowed) {
576 error_report("Option '-device %s' cannot be handled by this machine",
577 object_class_get_name(object_get_class(OBJECT(sbdev))));
578 exit(1);
579 }
580 }
581
582 static void machine_init_notify(Notifier *notifier, void *data)
583 {
584 MachineState *machine = MACHINE(qdev_get_machine());
585
586 /*
587 * Loop through all dynamically created sysbus devices and check if they are
588 * all allowed. If a device is not allowed, error out.
589 */
590 foreach_dynamic_sysbus_device(validate_sysbus_device, machine);
591 }
592
593 HotpluggableCPUList *machine_query_hotpluggable_cpus(MachineState *machine)
594 {
595 int i;
596 HotpluggableCPUList *head = NULL;
597 MachineClass *mc = MACHINE_GET_CLASS(machine);
598
599 /* force board to initialize possible_cpus if it hasn't been done yet */
600 mc->possible_cpu_arch_ids(machine);
601
602 for (i = 0; i < machine->possible_cpus->len; i++) {
603 Object *cpu;
604 HotpluggableCPUList *list_item = g_new0(typeof(*list_item), 1);
605 HotpluggableCPU *cpu_item = g_new0(typeof(*cpu_item), 1);
606
607 cpu_item->type = g_strdup(machine->possible_cpus->cpus[i].type);
608 cpu_item->vcpus_count = machine->possible_cpus->cpus[i].vcpus_count;
609 cpu_item->props = g_memdup(&machine->possible_cpus->cpus[i].props,
610 sizeof(*cpu_item->props));
611
612 cpu = machine->possible_cpus->cpus[i].cpu;
613 if (cpu) {
614 cpu_item->has_qom_path = true;
615 cpu_item->qom_path = object_get_canonical_path(cpu);
616 }
617 list_item->value = cpu_item;
618 list_item->next = head;
619 head = list_item;
620 }
621 return head;
622 }
623
624 /**
625 * machine_set_cpu_numa_node:
626 * @machine: machine object to modify
627 * @props: specifies which cpu objects to assign to
628 * numa node specified by @props.node_id
629 * @errp: if an error occurs, a pointer to an area to store the error
630 *
631 * Associate NUMA node specified by @props.node_id with cpu slots that
632 * match socket/core/thread-ids specified by @props. It's recommended to use
633 * query-hotpluggable-cpus.props values to specify affected cpu slots,
634 * which would lead to exact 1:1 mapping of cpu slots to NUMA node.
635 *
636 * However for CLI convenience it's possible to pass in subset of properties,
637 * which would affect all cpu slots that match it.
638 * Ex for pc machine:
639 * -smp 4,cores=2,sockets=2 -numa node,nodeid=0 -numa node,nodeid=1 \
640 * -numa cpu,node-id=0,socket_id=0 \
641 * -numa cpu,node-id=1,socket_id=1
642 * will assign all child cores of socket 0 to node 0 and
643 * of socket 1 to node 1.
644 *
645 * On attempt of reassigning (already assigned) cpu slot to another NUMA node,
646 * return error.
647 * Empty subset is disallowed and function will return with error in this case.
648 */
649 void machine_set_cpu_numa_node(MachineState *machine,
650 const CpuInstanceProperties *props, Error **errp)
651 {
652 MachineClass *mc = MACHINE_GET_CLASS(machine);
653 bool match = false;
654 int i;
655
656 if (!mc->possible_cpu_arch_ids) {
657 error_setg(errp, "mapping of CPUs to NUMA node is not supported");
658 return;
659 }
660
661 /* disabling node mapping is not supported, forbid it */
662 assert(props->has_node_id);
663
664 /* force board to initialize possible_cpus if it hasn't been done yet */
665 mc->possible_cpu_arch_ids(machine);
666
667 for (i = 0; i < machine->possible_cpus->len; i++) {
668 CPUArchId *slot = &machine->possible_cpus->cpus[i];
669
670 /* reject unsupported by board properties */
671 if (props->has_thread_id && !slot->props.has_thread_id) {
672 error_setg(errp, "thread-id is not supported");
673 return;
674 }
675
676 if (props->has_core_id && !slot->props.has_core_id) {
677 error_setg(errp, "core-id is not supported");
678 return;
679 }
680
681 if (props->has_socket_id && !slot->props.has_socket_id) {
682 error_setg(errp, "socket-id is not supported");
683 return;
684 }
685
686 if (props->has_die_id && !slot->props.has_die_id) {
687 error_setg(errp, "die-id is not supported");
688 return;
689 }
690
691 /* skip slots with explicit mismatch */
692 if (props->has_thread_id && props->thread_id != slot->props.thread_id) {
693 continue;
694 }
695
696 if (props->has_core_id && props->core_id != slot->props.core_id) {
697 continue;
698 }
699
700 if (props->has_die_id && props->die_id != slot->props.die_id) {
701 continue;
702 }
703
704 if (props->has_socket_id && props->socket_id != slot->props.socket_id) {
705 continue;
706 }
707
708 /* reject assignment if slot is already assigned, for compatibility
709 * of legacy cpu_index mapping with SPAPR core based mapping do not
710 * error out if cpu thread and matched core have the same node-id */
711 if (slot->props.has_node_id &&
712 slot->props.node_id != props->node_id) {
713 error_setg(errp, "CPU is already assigned to node-id: %" PRId64,
714 slot->props.node_id);
715 return;
716 }
717
718 /* assign slot to node as it's matched '-numa cpu' key */
719 match = true;
720 slot->props.node_id = props->node_id;
721 slot->props.has_node_id = props->has_node_id;
722 }
723
724 if (!match) {
725 error_setg(errp, "no match found");
726 }
727 }
728
729 static void machine_class_init(ObjectClass *oc, void *data)
730 {
731 MachineClass *mc = MACHINE_CLASS(oc);
732
733 /* Default 128 MB as guest ram size */
734 mc->default_ram_size = 128 * MiB;
735 mc->rom_file_has_mr = true;
736
737 /* numa node memory size aligned on 8MB by default.
738 * On Linux, each node's border has to be 8MB aligned
739 */
740 mc->numa_mem_align_shift = 23;
741 mc->numa_auto_assign_ram = numa_default_auto_assign_ram;
742
743 object_class_property_add_str(oc, "accel",
744 machine_get_accel, machine_set_accel, &error_abort);
745 object_class_property_set_description(oc, "accel",
746 "Accelerator list", &error_abort);
747
748 object_class_property_add(oc, "kernel-irqchip", "on|off|split",
749 NULL, machine_set_kernel_irqchip,
750 NULL, NULL, &error_abort);
751 object_class_property_set_description(oc, "kernel-irqchip",
752 "Configure KVM in-kernel irqchip", &error_abort);
753
754 object_class_property_add(oc, "kvm-shadow-mem", "int",
755 machine_get_kvm_shadow_mem, machine_set_kvm_shadow_mem,
756 NULL, NULL, &error_abort);
757 object_class_property_set_description(oc, "kvm-shadow-mem",
758 "KVM shadow MMU size", &error_abort);
759
760 object_class_property_add_str(oc, "kernel",
761 machine_get_kernel, machine_set_kernel, &error_abort);
762 object_class_property_set_description(oc, "kernel",
763 "Linux kernel image file", &error_abort);
764
765 object_class_property_add_str(oc, "initrd",
766 machine_get_initrd, machine_set_initrd, &error_abort);
767 object_class_property_set_description(oc, "initrd",
768 "Linux initial ramdisk file", &error_abort);
769
770 object_class_property_add_str(oc, "append",
771 machine_get_append, machine_set_append, &error_abort);
772 object_class_property_set_description(oc, "append",
773 "Linux kernel command line", &error_abort);
774
775 object_class_property_add_str(oc, "dtb",
776 machine_get_dtb, machine_set_dtb, &error_abort);
777 object_class_property_set_description(oc, "dtb",
778 "Linux kernel device tree file", &error_abort);
779
780 object_class_property_add_str(oc, "dumpdtb",
781 machine_get_dumpdtb, machine_set_dumpdtb, &error_abort);
782 object_class_property_set_description(oc, "dumpdtb",
783 "Dump current dtb to a file and quit", &error_abort);
784
785 object_class_property_add(oc, "phandle-start", "int",
786 machine_get_phandle_start, machine_set_phandle_start,
787 NULL, NULL, &error_abort);
788 object_class_property_set_description(oc, "phandle-start",
789 "The first phandle ID we may generate dynamically", &error_abort);
790
791 object_class_property_add_str(oc, "dt-compatible",
792 machine_get_dt_compatible, machine_set_dt_compatible, &error_abort);
793 object_class_property_set_description(oc, "dt-compatible",
794 "Overrides the \"compatible\" property of the dt root node",
795 &error_abort);
796
797 object_class_property_add_bool(oc, "dump-guest-core",
798 machine_get_dump_guest_core, machine_set_dump_guest_core, &error_abort);
799 object_class_property_set_description(oc, "dump-guest-core",
800 "Include guest memory in a core dump", &error_abort);
801
802 object_class_property_add_bool(oc, "mem-merge",
803 machine_get_mem_merge, machine_set_mem_merge, &error_abort);
804 object_class_property_set_description(oc, "mem-merge",
805 "Enable/disable memory merge support", &error_abort);
806
807 object_class_property_add_bool(oc, "usb",
808 machine_get_usb, machine_set_usb, &error_abort);
809 object_class_property_set_description(oc, "usb",
810 "Set on/off to enable/disable usb", &error_abort);
811
812 object_class_property_add_bool(oc, "graphics",
813 machine_get_graphics, machine_set_graphics, &error_abort);
814 object_class_property_set_description(oc, "graphics",
815 "Set on/off to enable/disable graphics emulation", &error_abort);
816
817 object_class_property_add_bool(oc, "igd-passthru",
818 machine_get_igd_gfx_passthru, machine_set_igd_gfx_passthru,
819 &error_abort);
820 object_class_property_set_description(oc, "igd-passthru",
821 "Set on/off to enable/disable igd passthrou", &error_abort);
822
823 object_class_property_add_str(oc, "firmware",
824 machine_get_firmware, machine_set_firmware,
825 &error_abort);
826 object_class_property_set_description(oc, "firmware",
827 "Firmware image", &error_abort);
828
829 object_class_property_add_bool(oc, "suppress-vmdesc",
830 machine_get_suppress_vmdesc, machine_set_suppress_vmdesc,
831 &error_abort);
832 object_class_property_set_description(oc, "suppress-vmdesc",
833 "Set on to disable self-describing migration", &error_abort);
834
835 object_class_property_add_bool(oc, "enforce-config-section",
836 machine_get_enforce_config_section, machine_set_enforce_config_section,
837 &error_abort);
838 object_class_property_set_description(oc, "enforce-config-section",
839 "Set on to enforce configuration section migration", &error_abort);
840
841 object_class_property_add_str(oc, "memory-encryption",
842 machine_get_memory_encryption, machine_set_memory_encryption,
843 &error_abort);
844 object_class_property_set_description(oc, "memory-encryption",
845 "Set memory encryption object to use", &error_abort);
846 }
847
848 static void machine_class_base_init(ObjectClass *oc, void *data)
849 {
850 if (!object_class_is_abstract(oc)) {
851 MachineClass *mc = MACHINE_CLASS(oc);
852 const char *cname = object_class_get_name(oc);
853 assert(g_str_has_suffix(cname, TYPE_MACHINE_SUFFIX));
854 mc->name = g_strndup(cname,
855 strlen(cname) - strlen(TYPE_MACHINE_SUFFIX));
856 mc->compat_props = g_ptr_array_new();
857 }
858 }
859
860 static void machine_initfn(Object *obj)
861 {
862 MachineState *ms = MACHINE(obj);
863 MachineClass *mc = MACHINE_GET_CLASS(obj);
864
865 ms->kernel_irqchip_allowed = true;
866 ms->kernel_irqchip_split = mc->default_kernel_irqchip_split;
867 ms->kvm_shadow_mem = -1;
868 ms->dump_guest_core = true;
869 ms->mem_merge = true;
870 ms->enable_graphics = true;
871
872 if (mc->nvdimm_supported) {
873 Object *obj = OBJECT(ms);
874
875 ms->nvdimms_state = g_new0(NVDIMMState, 1);
876 object_property_add_bool(obj, "nvdimm",
877 machine_get_nvdimm, machine_set_nvdimm,
878 &error_abort);
879 object_property_set_description(obj, "nvdimm",
880 "Set on/off to enable/disable "
881 "NVDIMM instantiation", NULL);
882
883 object_property_add_str(obj, "nvdimm-persistence",
884 machine_get_nvdimm_persistence,
885 machine_set_nvdimm_persistence,
886 &error_abort);
887 object_property_set_description(obj, "nvdimm-persistence",
888 "Set NVDIMM persistence"
889 "Valid values are cpu, mem-ctrl",
890 NULL);
891 }
892
893
894 /* Register notifier when init is done for sysbus sanity checks */
895 ms->sysbus_notifier.notify = machine_init_notify;
896 qemu_add_machine_init_done_notifier(&ms->sysbus_notifier);
897 }
898
899 static void machine_finalize(Object *obj)
900 {
901 MachineState *ms = MACHINE(obj);
902
903 g_free(ms->accel);
904 g_free(ms->kernel_filename);
905 g_free(ms->initrd_filename);
906 g_free(ms->kernel_cmdline);
907 g_free(ms->dtb);
908 g_free(ms->dumpdtb);
909 g_free(ms->dt_compatible);
910 g_free(ms->firmware);
911 g_free(ms->device_memory);
912 g_free(ms->nvdimms_state);
913 }
914
915 bool machine_usb(MachineState *machine)
916 {
917 return machine->usb;
918 }
919
920 bool machine_kernel_irqchip_allowed(MachineState *machine)
921 {
922 return machine->kernel_irqchip_allowed;
923 }
924
925 bool machine_kernel_irqchip_required(MachineState *machine)
926 {
927 return machine->kernel_irqchip_required;
928 }
929
930 bool machine_kernel_irqchip_split(MachineState *machine)
931 {
932 return machine->kernel_irqchip_split;
933 }
934
935 int machine_kvm_shadow_mem(MachineState *machine)
936 {
937 return machine->kvm_shadow_mem;
938 }
939
940 int machine_phandle_start(MachineState *machine)
941 {
942 return machine->phandle_start;
943 }
944
945 bool machine_dump_guest_core(MachineState *machine)
946 {
947 return machine->dump_guest_core;
948 }
949
950 bool machine_mem_merge(MachineState *machine)
951 {
952 return machine->mem_merge;
953 }
954
955 static char *cpu_slot_to_string(const CPUArchId *cpu)
956 {
957 GString *s = g_string_new(NULL);
958 if (cpu->props.has_socket_id) {
959 g_string_append_printf(s, "socket-id: %"PRId64, cpu->props.socket_id);
960 }
961 if (cpu->props.has_die_id) {
962 g_string_append_printf(s, "die-id: %"PRId64, cpu->props.die_id);
963 }
964 if (cpu->props.has_core_id) {
965 if (s->len) {
966 g_string_append_printf(s, ", ");
967 }
968 g_string_append_printf(s, "core-id: %"PRId64, cpu->props.core_id);
969 }
970 if (cpu->props.has_thread_id) {
971 if (s->len) {
972 g_string_append_printf(s, ", ");
973 }
974 g_string_append_printf(s, "thread-id: %"PRId64, cpu->props.thread_id);
975 }
976 return g_string_free(s, false);
977 }
978
979 static void machine_numa_finish_cpu_init(MachineState *machine)
980 {
981 int i;
982 bool default_mapping;
983 GString *s = g_string_new(NULL);
984 MachineClass *mc = MACHINE_GET_CLASS(machine);
985 const CPUArchIdList *possible_cpus = mc->possible_cpu_arch_ids(machine);
986
987 assert(nb_numa_nodes);
988 for (i = 0; i < possible_cpus->len; i++) {
989 if (possible_cpus->cpus[i].props.has_node_id) {
990 break;
991 }
992 }
993 default_mapping = (i == possible_cpus->len);
994
995 for (i = 0; i < possible_cpus->len; i++) {
996 const CPUArchId *cpu_slot = &possible_cpus->cpus[i];
997
998 if (!cpu_slot->props.has_node_id) {
999 /* fetch default mapping from board and enable it */
1000 CpuInstanceProperties props = cpu_slot->props;
1001
1002 props.node_id = mc->get_default_cpu_node_id(machine, i);
1003 if (!default_mapping) {
1004 /* record slots with not set mapping,
1005 * TODO: make it hard error in future */
1006 char *cpu_str = cpu_slot_to_string(cpu_slot);
1007 g_string_append_printf(s, "%sCPU %d [%s]",
1008 s->len ? ", " : "", i, cpu_str);
1009 g_free(cpu_str);
1010
1011 /* non mapped cpus used to fallback to node 0 */
1012 props.node_id = 0;
1013 }
1014
1015 props.has_node_id = true;
1016 machine_set_cpu_numa_node(machine, &props, &error_fatal);
1017 }
1018 }
1019 if (s->len && !qtest_enabled()) {
1020 warn_report("CPU(s) not present in any NUMA nodes: %s",
1021 s->str);
1022 warn_report("All CPU(s) up to maxcpus should be described "
1023 "in NUMA config, ability to start up with partial NUMA "
1024 "mappings is obsoleted and will be removed in future");
1025 }
1026 g_string_free(s, true);
1027 }
1028
1029 void machine_run_board_init(MachineState *machine)
1030 {
1031 MachineClass *machine_class = MACHINE_GET_CLASS(machine);
1032
1033 numa_complete_configuration(machine);
1034 if (nb_numa_nodes) {
1035 machine_numa_finish_cpu_init(machine);
1036 }
1037
1038 /* If the machine supports the valid_cpu_types check and the user
1039 * specified a CPU with -cpu check here that the user CPU is supported.
1040 */
1041 if (machine_class->valid_cpu_types && machine->cpu_type) {
1042 ObjectClass *class = object_class_by_name(machine->cpu_type);
1043 int i;
1044
1045 for (i = 0; machine_class->valid_cpu_types[i]; i++) {
1046 if (object_class_dynamic_cast(class,
1047 machine_class->valid_cpu_types[i])) {
1048 /* The user specificed CPU is in the valid field, we are
1049 * good to go.
1050 */
1051 break;
1052 }
1053 }
1054
1055 if (!machine_class->valid_cpu_types[i]) {
1056 /* The user specified CPU is not valid */
1057 error_report("Invalid CPU type: %s", machine->cpu_type);
1058 error_printf("The valid types are: %s",
1059 machine_class->valid_cpu_types[0]);
1060 for (i = 1; machine_class->valid_cpu_types[i]; i++) {
1061 error_printf(", %s", machine_class->valid_cpu_types[i]);
1062 }
1063 error_printf("\n");
1064
1065 exit(1);
1066 }
1067 }
1068
1069 machine_class->init(machine);
1070 }
1071
1072 static const TypeInfo machine_info = {
1073 .name = TYPE_MACHINE,
1074 .parent = TYPE_OBJECT,
1075 .abstract = true,
1076 .class_size = sizeof(MachineClass),
1077 .class_init = machine_class_init,
1078 .class_base_init = machine_class_base_init,
1079 .instance_size = sizeof(MachineState),
1080 .instance_init = machine_initfn,
1081 .instance_finalize = machine_finalize,
1082 };
1083
1084 static void machine_register_types(void)
1085 {
1086 type_register_static(&machine_info);
1087 }
1088
1089 type_init(machine_register_types)