s390x: refactor reset/reipl handling
[qemu.git] / hw / s390x / s390-virtio-ccw.c
1 /*
2 * virtio ccw machine
3 *
4 * Copyright 2012 IBM Corp.
5 * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
6 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
7 *
8 * This work is licensed under the terms of the GNU GPL, version 2 or (at
9 * your option) any later version. See the COPYING file in the top-level
10 * directory.
11 */
12
13 #include "qemu/osdep.h"
14 #include "qapi/error.h"
15 #include "cpu.h"
16 #include "hw/boards.h"
17 #include "exec/address-spaces.h"
18 #include "hw/s390x/s390-virtio-hcall.h"
19 #include "hw/s390x/sclp.h"
20 #include "hw/s390x/s390_flic.h"
21 #include "hw/s390x/ioinst.h"
22 #include "hw/s390x/css.h"
23 #include "virtio-ccw.h"
24 #include "qemu/config-file.h"
25 #include "qemu/error-report.h"
26 #include "qemu/option.h"
27 #include "s390-pci-bus.h"
28 #include "hw/s390x/storage-keys.h"
29 #include "hw/s390x/storage-attributes.h"
30 #include "hw/s390x/event-facility.h"
31 #include "hw/compat.h"
32 #include "ipl.h"
33 #include "hw/s390x/s390-virtio-ccw.h"
34 #include "hw/s390x/css-bridge.h"
35 #include "migration/register.h"
36 #include "cpu_models.h"
37 #include "hw/nmi.h"
38
39 S390CPU *s390_cpu_addr2state(uint16_t cpu_addr)
40 {
41 static MachineState *ms;
42
43 if (!ms) {
44 ms = MACHINE(qdev_get_machine());
45 g_assert(ms->possible_cpus);
46 }
47
48 /* CPU address corresponds to the core_id and the index */
49 if (cpu_addr >= ms->possible_cpus->len) {
50 return NULL;
51 }
52 return S390_CPU(ms->possible_cpus->cpus[cpu_addr].cpu);
53 }
54
55 static S390CPU *s390x_new_cpu(const char *typename, uint32_t core_id,
56 Error **errp)
57 {
58 S390CPU *cpu = S390_CPU(object_new(typename));
59 Error *err = NULL;
60
61 object_property_set_int(OBJECT(cpu), core_id, "core-id", &err);
62 if (err != NULL) {
63 goto out;
64 }
65 object_property_set_bool(OBJECT(cpu), true, "realized", &err);
66
67 out:
68 object_unref(OBJECT(cpu));
69 if (err) {
70 error_propagate(errp, err);
71 cpu = NULL;
72 }
73 return cpu;
74 }
75
76 static void s390_init_cpus(MachineState *machine)
77 {
78 MachineClass *mc = MACHINE_GET_CLASS(machine);
79 int i;
80
81 /* initialize possible_cpus */
82 mc->possible_cpu_arch_ids(machine);
83
84 for (i = 0; i < smp_cpus; i++) {
85 s390x_new_cpu(machine->cpu_type, i, &error_fatal);
86 }
87 }
88
89 static const char *const reset_dev_types[] = {
90 TYPE_VIRTUAL_CSS_BRIDGE,
91 "s390-sclp-event-facility",
92 "s390-flic",
93 "diag288",
94 };
95
96 static void subsystem_reset(void)
97 {
98 DeviceState *dev;
99 int i;
100
101 for (i = 0; i < ARRAY_SIZE(reset_dev_types); i++) {
102 dev = DEVICE(object_resolve_path_type("", reset_dev_types[i], NULL));
103 if (dev) {
104 qdev_reset_all(dev);
105 }
106 }
107 }
108
109 static int virtio_ccw_hcall_notify(const uint64_t *args)
110 {
111 uint64_t subch_id = args[0];
112 uint64_t queue = args[1];
113 SubchDev *sch;
114 int cssid, ssid, schid, m;
115
116 if (ioinst_disassemble_sch_ident(subch_id, &m, &cssid, &ssid, &schid)) {
117 return -EINVAL;
118 }
119 sch = css_find_subch(m, cssid, ssid, schid);
120 if (!sch || !css_subch_visible(sch)) {
121 return -EINVAL;
122 }
123 if (queue >= VIRTIO_QUEUE_MAX) {
124 return -EINVAL;
125 }
126 virtio_queue_notify(virtio_ccw_get_vdev(sch), queue);
127 return 0;
128
129 }
130
131 static int virtio_ccw_hcall_early_printk(const uint64_t *args)
132 {
133 uint64_t mem = args[0];
134
135 if (mem < ram_size) {
136 /* Early printk */
137 return 0;
138 }
139 return -EINVAL;
140 }
141
142 static void virtio_ccw_register_hcalls(void)
143 {
144 s390_register_virtio_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY,
145 virtio_ccw_hcall_notify);
146 /* Tolerate early printk. */
147 s390_register_virtio_hypercall(KVM_S390_VIRTIO_NOTIFY,
148 virtio_ccw_hcall_early_printk);
149 }
150
151 /*
152 * KVM does only support memory slots up to KVM_MEM_MAX_NR_PAGES pages
153 * as the dirty bitmap must be managed by bitops that take an int as
154 * position indicator. If we have a guest beyond that we will split off
155 * new subregions. The split must happen on a segment boundary (1MB).
156 */
157 #define KVM_MEM_MAX_NR_PAGES ((1ULL << 31) - 1)
158 #define SEG_MSK (~0xfffffULL)
159 #define KVM_SLOT_MAX_BYTES ((KVM_MEM_MAX_NR_PAGES * TARGET_PAGE_SIZE) & SEG_MSK)
160 static void s390_memory_init(ram_addr_t mem_size)
161 {
162 MemoryRegion *sysmem = get_system_memory();
163 ram_addr_t chunk, offset = 0;
164 unsigned int number = 0;
165 gchar *name;
166
167 /* allocate RAM for core */
168 name = g_strdup_printf("s390.ram");
169 while (mem_size) {
170 MemoryRegion *ram = g_new(MemoryRegion, 1);
171 uint64_t size = mem_size;
172
173 /* KVM does not allow memslots >= 8 TB */
174 chunk = MIN(size, KVM_SLOT_MAX_BYTES);
175 memory_region_allocate_system_memory(ram, NULL, name, chunk);
176 memory_region_add_subregion(sysmem, offset, ram);
177 mem_size -= chunk;
178 offset += chunk;
179 g_free(name);
180 name = g_strdup_printf("s390.ram.%u", ++number);
181 }
182 g_free(name);
183
184 /* Initialize storage key device */
185 s390_skeys_init();
186 /* Initialize storage attributes device */
187 s390_stattrib_init();
188 }
189
190 #define S390_TOD_CLOCK_VALUE_MISSING 0x00
191 #define S390_TOD_CLOCK_VALUE_PRESENT 0x01
192
193 static void gtod_save(QEMUFile *f, void *opaque)
194 {
195 uint64_t tod_low;
196 uint8_t tod_high;
197 int r;
198
199 r = s390_get_clock(&tod_high, &tod_low);
200 if (r) {
201 warn_report("Unable to get guest clock for migration: %s",
202 strerror(-r));
203 error_printf("Guest clock will not be migrated "
204 "which could cause the guest to hang.");
205 qemu_put_byte(f, S390_TOD_CLOCK_VALUE_MISSING);
206 return;
207 }
208
209 qemu_put_byte(f, S390_TOD_CLOCK_VALUE_PRESENT);
210 qemu_put_byte(f, tod_high);
211 qemu_put_be64(f, tod_low);
212 }
213
214 static int gtod_load(QEMUFile *f, void *opaque, int version_id)
215 {
216 uint64_t tod_low;
217 uint8_t tod_high;
218 int r;
219
220 if (qemu_get_byte(f) == S390_TOD_CLOCK_VALUE_MISSING) {
221 warn_report("Guest clock was not migrated. This could "
222 "cause the guest to hang.");
223 return 0;
224 }
225
226 tod_high = qemu_get_byte(f);
227 tod_low = qemu_get_be64(f);
228
229 r = s390_set_clock(&tod_high, &tod_low);
230 if (r) {
231 error_report("Unable to set KVM guest TOD clock: %s", strerror(-r));
232 }
233
234 return r;
235 }
236
237 static SaveVMHandlers savevm_gtod = {
238 .save_state = gtod_save,
239 .load_state = gtod_load,
240 };
241
242 static void s390_init_ipl_dev(const char *kernel_filename,
243 const char *kernel_cmdline,
244 const char *initrd_filename, const char *firmware,
245 const char *netboot_fw, bool enforce_bios)
246 {
247 Object *new = object_new(TYPE_S390_IPL);
248 DeviceState *dev = DEVICE(new);
249 char *netboot_fw_prop;
250
251 if (kernel_filename) {
252 qdev_prop_set_string(dev, "kernel", kernel_filename);
253 }
254 if (initrd_filename) {
255 qdev_prop_set_string(dev, "initrd", initrd_filename);
256 }
257 qdev_prop_set_string(dev, "cmdline", kernel_cmdline);
258 qdev_prop_set_string(dev, "firmware", firmware);
259 qdev_prop_set_bit(dev, "enforce_bios", enforce_bios);
260 netboot_fw_prop = object_property_get_str(new, "netboot_fw", &error_abort);
261 if (!strlen(netboot_fw_prop)) {
262 qdev_prop_set_string(dev, "netboot_fw", netboot_fw);
263 }
264 g_free(netboot_fw_prop);
265 object_property_add_child(qdev_get_machine(), TYPE_S390_IPL,
266 new, NULL);
267 object_unref(new);
268 qdev_init_nofail(dev);
269 }
270
271 static void s390_create_virtio_net(BusState *bus, const char *name)
272 {
273 int i;
274
275 for (i = 0; i < nb_nics; i++) {
276 NICInfo *nd = &nd_table[i];
277 DeviceState *dev;
278
279 if (!nd->model) {
280 nd->model = g_strdup("virtio");
281 }
282
283 qemu_check_nic_model(nd, "virtio");
284
285 dev = qdev_create(bus, name);
286 qdev_set_nic_properties(dev, nd);
287 qdev_init_nofail(dev);
288 }
289 }
290
291 static void s390_create_sclpconsole(const char *type, Chardev *chardev)
292 {
293 DeviceState *dev;
294
295 dev = qdev_create(sclp_get_event_facility_bus(), type);
296 qdev_prop_set_chr(dev, "chardev", chardev);
297 qdev_init_nofail(dev);
298 }
299
300 static void ccw_init(MachineState *machine)
301 {
302 int ret;
303 VirtualCssBus *css_bus;
304 DeviceState *dev;
305
306 s390_sclp_init();
307 s390_memory_init(machine->ram_size);
308
309 /* init CPUs (incl. CPU model) early so s390_has_feature() works */
310 s390_init_cpus(machine);
311
312 s390_flic_init();
313
314 /* init the SIGP facility */
315 s390_init_sigp();
316
317 /* get a BUS */
318 css_bus = virtual_css_bus_init();
319 s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline,
320 machine->initrd_filename, "s390-ccw.img",
321 "s390-netboot.img", true);
322
323 /*
324 * We cannot easily make the pci host bridge conditional as older QEMUs
325 * always created it. Doing so would break migration across QEMU versions.
326 */
327 dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE);
328 object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE,
329 OBJECT(dev), NULL);
330 qdev_init_nofail(dev);
331
332 /* register hypercalls */
333 virtio_ccw_register_hcalls();
334
335 s390_enable_css_support(s390_cpu_addr2state(0));
336 /*
337 * Non mcss-e enabled guests only see the devices from the default
338 * css, which is determined by the value of the squash_mcss property.
339 */
340 if (css_bus->squash_mcss) {
341 ret = css_create_css_image(0, true);
342 } else {
343 ret = css_create_css_image(VIRTUAL_CSSID, true);
344 }
345 if (qemu_opt_get(qemu_get_machine_opts(), "s390-squash-mcss")) {
346 warn_report("The machine property 's390-squash-mcss' is deprecated"
347 " (obsoleted by lifting the cssid restrictions).");
348 }
349
350 assert(ret == 0);
351 if (css_migration_enabled()) {
352 css_register_vmstate();
353 }
354
355 /* Create VirtIO network adapters */
356 s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw");
357
358 /* init consoles */
359 if (serial_hd(0)) {
360 s390_create_sclpconsole("sclpconsole", serial_hd(0));
361 }
362 if (serial_hd(1)) {
363 s390_create_sclpconsole("sclplmconsole", serial_hd(1));
364 }
365
366 /* Register savevm handler for guest TOD clock */
367 register_savevm_live(NULL, "todclock", 0, 1, &savevm_gtod, NULL);
368 }
369
370 static void s390_cpu_plug(HotplugHandler *hotplug_dev,
371 DeviceState *dev, Error **errp)
372 {
373 MachineState *ms = MACHINE(hotplug_dev);
374 S390CPU *cpu = S390_CPU(dev);
375
376 g_assert(!ms->possible_cpus->cpus[cpu->env.core_id].cpu);
377 ms->possible_cpus->cpus[cpu->env.core_id].cpu = OBJECT(dev);
378
379 if (dev->hotplugged) {
380 raise_irq_cpu_hotplug();
381 }
382 }
383
384 static inline void s390_do_cpu_ipl(CPUState *cs, run_on_cpu_data arg)
385 {
386 S390CPU *cpu = S390_CPU(cs);
387
388 s390_ipl_prepare_cpu(cpu);
389 s390_cpu_set_state(S390_CPU_STATE_OPERATING, cpu);
390 }
391
392 static void s390_machine_reset(void)
393 {
394 enum s390_reset reset_type;
395 CPUState *cs, *t;
396
397 /* get the reset parameters, reset them once done */
398 s390_ipl_get_reset_request(&cs, &reset_type);
399
400 /* all CPUs are paused and synchronized at this point */
401 s390_cmma_reset();
402
403 switch (reset_type) {
404 case S390_RESET_EXTERNAL:
405 case S390_RESET_REIPL:
406 qemu_devices_reset();
407 s390_crypto_reset();
408
409 /* configure and start the ipl CPU only */
410 run_on_cpu(cs, s390_do_cpu_ipl, RUN_ON_CPU_NULL);
411 break;
412 case S390_RESET_MODIFIED_CLEAR:
413 CPU_FOREACH(t) {
414 run_on_cpu(t, s390_do_cpu_full_reset, RUN_ON_CPU_NULL);
415 }
416 subsystem_reset();
417 s390_crypto_reset();
418 run_on_cpu(cs, s390_do_cpu_load_normal, RUN_ON_CPU_NULL);
419 break;
420 case S390_RESET_LOAD_NORMAL:
421 CPU_FOREACH(t) {
422 run_on_cpu(t, s390_do_cpu_reset, RUN_ON_CPU_NULL);
423 }
424 subsystem_reset();
425 run_on_cpu(cs, s390_do_cpu_initial_reset, RUN_ON_CPU_NULL);
426 run_on_cpu(cs, s390_do_cpu_load_normal, RUN_ON_CPU_NULL);
427 break;
428 default:
429 g_assert_not_reached();
430 }
431 s390_ipl_clear_reset_request();
432 }
433
434 static void s390_machine_device_plug(HotplugHandler *hotplug_dev,
435 DeviceState *dev, Error **errp)
436 {
437 if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
438 s390_cpu_plug(hotplug_dev, dev, errp);
439 }
440 }
441
442 static void s390_machine_device_unplug_request(HotplugHandler *hotplug_dev,
443 DeviceState *dev, Error **errp)
444 {
445 if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
446 error_setg(errp, "CPU hot unplug not supported on this machine");
447 return;
448 }
449 }
450
451 static CpuInstanceProperties s390_cpu_index_to_props(MachineState *ms,
452 unsigned cpu_index)
453 {
454 MachineClass *mc = MACHINE_GET_CLASS(ms);
455 const CPUArchIdList *possible_cpus = mc->possible_cpu_arch_ids(ms);
456
457 assert(cpu_index < possible_cpus->len);
458 return possible_cpus->cpus[cpu_index].props;
459 }
460
461 static const CPUArchIdList *s390_possible_cpu_arch_ids(MachineState *ms)
462 {
463 int i;
464
465 if (ms->possible_cpus) {
466 g_assert(ms->possible_cpus && ms->possible_cpus->len == max_cpus);
467 return ms->possible_cpus;
468 }
469
470 ms->possible_cpus = g_malloc0(sizeof(CPUArchIdList) +
471 sizeof(CPUArchId) * max_cpus);
472 ms->possible_cpus->len = max_cpus;
473 for (i = 0; i < ms->possible_cpus->len; i++) {
474 ms->possible_cpus->cpus[i].type = ms->cpu_type;
475 ms->possible_cpus->cpus[i].vcpus_count = 1;
476 ms->possible_cpus->cpus[i].arch_id = i;
477 ms->possible_cpus->cpus[i].props.has_core_id = true;
478 ms->possible_cpus->cpus[i].props.core_id = i;
479 }
480
481 return ms->possible_cpus;
482 }
483
484 static HotplugHandler *s390_get_hotplug_handler(MachineState *machine,
485 DeviceState *dev)
486 {
487 if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
488 return HOTPLUG_HANDLER(machine);
489 }
490 return NULL;
491 }
492
493 static void s390_hot_add_cpu(const int64_t id, Error **errp)
494 {
495 MachineState *machine = MACHINE(qdev_get_machine());
496 ObjectClass *oc;
497
498 g_assert(machine->possible_cpus->cpus[0].cpu);
499 oc = OBJECT_CLASS(CPU_GET_CLASS(machine->possible_cpus->cpus[0].cpu));
500
501 s390x_new_cpu(object_class_get_name(oc), id, errp);
502 }
503
504 static void s390_nmi(NMIState *n, int cpu_index, Error **errp)
505 {
506 CPUState *cs = qemu_get_cpu(cpu_index);
507
508 s390_cpu_restart(S390_CPU(cs));
509 }
510
511 static void ccw_machine_class_init(ObjectClass *oc, void *data)
512 {
513 MachineClass *mc = MACHINE_CLASS(oc);
514 NMIClass *nc = NMI_CLASS(oc);
515 HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
516 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
517
518 s390mc->ri_allowed = true;
519 s390mc->cpu_model_allowed = true;
520 s390mc->css_migration_enabled = true;
521 mc->init = ccw_init;
522 mc->reset = s390_machine_reset;
523 mc->hot_add_cpu = s390_hot_add_cpu;
524 mc->block_default_type = IF_VIRTIO;
525 mc->no_cdrom = 1;
526 mc->no_floppy = 1;
527 mc->no_parallel = 1;
528 mc->no_sdcard = 1;
529 mc->max_cpus = S390_MAX_CPUS;
530 mc->has_hotpluggable_cpus = true;
531 assert(!mc->get_hotplug_handler);
532 mc->get_hotplug_handler = s390_get_hotplug_handler;
533 mc->cpu_index_to_instance_props = s390_cpu_index_to_props;
534 mc->possible_cpu_arch_ids = s390_possible_cpu_arch_ids;
535 /* it is overridden with 'host' cpu *in kvm_arch_init* */
536 mc->default_cpu_type = S390_CPU_TYPE_NAME("qemu");
537 hc->plug = s390_machine_device_plug;
538 hc->unplug_request = s390_machine_device_unplug_request;
539 nc->nmi_monitor_handler = s390_nmi;
540 }
541
542 static inline bool machine_get_aes_key_wrap(Object *obj, Error **errp)
543 {
544 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
545
546 return ms->aes_key_wrap;
547 }
548
549 static inline void machine_set_aes_key_wrap(Object *obj, bool value,
550 Error **errp)
551 {
552 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
553
554 ms->aes_key_wrap = value;
555 }
556
557 static inline bool machine_get_dea_key_wrap(Object *obj, Error **errp)
558 {
559 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
560
561 return ms->dea_key_wrap;
562 }
563
564 static inline void machine_set_dea_key_wrap(Object *obj, bool value,
565 Error **errp)
566 {
567 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
568
569 ms->dea_key_wrap = value;
570 }
571
572 static S390CcwMachineClass *current_mc;
573
574 static S390CcwMachineClass *get_machine_class(void)
575 {
576 if (unlikely(!current_mc)) {
577 /*
578 * No s390 ccw machine was instantiated, we are likely to
579 * be called for the 'none' machine. The properties will
580 * have their after-initialization values.
581 */
582 current_mc = S390_MACHINE_CLASS(
583 object_class_by_name(TYPE_S390_CCW_MACHINE));
584 }
585 return current_mc;
586 }
587
588 bool ri_allowed(void)
589 {
590 /* for "none" machine this results in true */
591 return get_machine_class()->ri_allowed;
592 }
593
594 bool cpu_model_allowed(void)
595 {
596 /* for "none" machine this results in true */
597 return get_machine_class()->cpu_model_allowed;
598 }
599
600 static char *machine_get_loadparm(Object *obj, Error **errp)
601 {
602 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
603
604 return g_memdup(ms->loadparm, sizeof(ms->loadparm));
605 }
606
607 static void machine_set_loadparm(Object *obj, const char *val, Error **errp)
608 {
609 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
610 int i;
611
612 for (i = 0; i < sizeof(ms->loadparm) && val[i]; i++) {
613 uint8_t c = qemu_toupper(val[i]); /* mimic HMC */
614
615 if (('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || (c == '.') ||
616 (c == ' ')) {
617 ms->loadparm[i] = c;
618 } else {
619 error_setg(errp, "LOADPARM: invalid character '%c' (ASCII 0x%02x)",
620 c, c);
621 return;
622 }
623 }
624
625 for (; i < sizeof(ms->loadparm); i++) {
626 ms->loadparm[i] = ' '; /* pad right with spaces */
627 }
628 }
629 static inline bool machine_get_squash_mcss(Object *obj, Error **errp)
630 {
631 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
632
633 return ms->s390_squash_mcss;
634 }
635
636 static inline void machine_set_squash_mcss(Object *obj, bool value,
637 Error **errp)
638 {
639 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
640
641 ms->s390_squash_mcss = value;
642 }
643
644 static inline void s390_machine_initfn(Object *obj)
645 {
646 object_property_add_bool(obj, "aes-key-wrap",
647 machine_get_aes_key_wrap,
648 machine_set_aes_key_wrap, NULL);
649 object_property_set_description(obj, "aes-key-wrap",
650 "enable/disable AES key wrapping using the CPACF wrapping key",
651 NULL);
652 object_property_set_bool(obj, true, "aes-key-wrap", NULL);
653
654 object_property_add_bool(obj, "dea-key-wrap",
655 machine_get_dea_key_wrap,
656 machine_set_dea_key_wrap, NULL);
657 object_property_set_description(obj, "dea-key-wrap",
658 "enable/disable DEA key wrapping using the CPACF wrapping key",
659 NULL);
660 object_property_set_bool(obj, true, "dea-key-wrap", NULL);
661 object_property_add_str(obj, "loadparm",
662 machine_get_loadparm, machine_set_loadparm, NULL);
663 object_property_set_description(obj, "loadparm",
664 "Up to 8 chars in set of [A-Za-z0-9. ] (lower case chars converted"
665 " to upper case) to pass to machine loader, boot manager,"
666 " and guest kernel",
667 NULL);
668 object_property_add_bool(obj, "s390-squash-mcss",
669 machine_get_squash_mcss,
670 machine_set_squash_mcss, NULL);
671 object_property_set_description(obj, "s390-squash-mcss", "(deprecated) "
672 "enable/disable squashing subchannels into the default css",
673 NULL);
674 object_property_set_bool(obj, false, "s390-squash-mcss", NULL);
675 }
676
677 static const TypeInfo ccw_machine_info = {
678 .name = TYPE_S390_CCW_MACHINE,
679 .parent = TYPE_MACHINE,
680 .abstract = true,
681 .instance_size = sizeof(S390CcwMachineState),
682 .instance_init = s390_machine_initfn,
683 .class_size = sizeof(S390CcwMachineClass),
684 .class_init = ccw_machine_class_init,
685 .interfaces = (InterfaceInfo[]) {
686 { TYPE_NMI },
687 { TYPE_HOTPLUG_HANDLER},
688 { }
689 },
690 };
691
692 bool css_migration_enabled(void)
693 {
694 return get_machine_class()->css_migration_enabled;
695 }
696
697 #define DEFINE_CCW_MACHINE(suffix, verstr, latest) \
698 static void ccw_machine_##suffix##_class_init(ObjectClass *oc, \
699 void *data) \
700 { \
701 MachineClass *mc = MACHINE_CLASS(oc); \
702 ccw_machine_##suffix##_class_options(mc); \
703 mc->desc = "VirtIO-ccw based S390 machine v" verstr; \
704 if (latest) { \
705 mc->alias = "s390-ccw-virtio"; \
706 mc->is_default = 1; \
707 } \
708 } \
709 static void ccw_machine_##suffix##_instance_init(Object *obj) \
710 { \
711 MachineState *machine = MACHINE(obj); \
712 current_mc = S390_MACHINE_CLASS(MACHINE_GET_CLASS(machine)); \
713 ccw_machine_##suffix##_instance_options(machine); \
714 } \
715 static const TypeInfo ccw_machine_##suffix##_info = { \
716 .name = MACHINE_TYPE_NAME("s390-ccw-virtio-" verstr), \
717 .parent = TYPE_S390_CCW_MACHINE, \
718 .class_init = ccw_machine_##suffix##_class_init, \
719 .instance_init = ccw_machine_##suffix##_instance_init, \
720 }; \
721 static void ccw_machine_register_##suffix(void) \
722 { \
723 type_register_static(&ccw_machine_##suffix##_info); \
724 } \
725 type_init(ccw_machine_register_##suffix)
726
727 #define CCW_COMPAT_2_12 \
728 HW_COMPAT_2_12
729
730 #define CCW_COMPAT_2_11 \
731 HW_COMPAT_2_11 \
732 {\
733 .driver = TYPE_SCLP_EVENT_FACILITY,\
734 .property = "allow_all_mask_sizes",\
735 .value = "off",\
736 },
737
738 #define CCW_COMPAT_2_10 \
739 HW_COMPAT_2_10
740
741 #define CCW_COMPAT_2_9 \
742 HW_COMPAT_2_9 \
743 {\
744 .driver = TYPE_S390_STATTRIB,\
745 .property = "migration-enabled",\
746 .value = "off",\
747 },
748
749 #define CCW_COMPAT_2_8 \
750 HW_COMPAT_2_8 \
751 {\
752 .driver = TYPE_S390_FLIC_COMMON,\
753 .property = "adapter_routes_max_batch",\
754 .value = "64",\
755 },
756
757 #define CCW_COMPAT_2_7 \
758 HW_COMPAT_2_7
759
760 #define CCW_COMPAT_2_6 \
761 HW_COMPAT_2_6 \
762 {\
763 .driver = TYPE_S390_IPL,\
764 .property = "iplbext_migration",\
765 .value = "off",\
766 }, {\
767 .driver = TYPE_VIRTUAL_CSS_BRIDGE,\
768 .property = "css_dev_path",\
769 .value = "off",\
770 },
771
772 #define CCW_COMPAT_2_5 \
773 HW_COMPAT_2_5
774
775 #define CCW_COMPAT_2_4 \
776 HW_COMPAT_2_4 \
777 {\
778 .driver = TYPE_S390_SKEYS,\
779 .property = "migration-enabled",\
780 .value = "off",\
781 },{\
782 .driver = "virtio-blk-ccw",\
783 .property = "max_revision",\
784 .value = "0",\
785 },{\
786 .driver = "virtio-balloon-ccw",\
787 .property = "max_revision",\
788 .value = "0",\
789 },{\
790 .driver = "virtio-serial-ccw",\
791 .property = "max_revision",\
792 .value = "0",\
793 },{\
794 .driver = "virtio-9p-ccw",\
795 .property = "max_revision",\
796 .value = "0",\
797 },{\
798 .driver = "virtio-rng-ccw",\
799 .property = "max_revision",\
800 .value = "0",\
801 },{\
802 .driver = "virtio-net-ccw",\
803 .property = "max_revision",\
804 .value = "0",\
805 },{\
806 .driver = "virtio-scsi-ccw",\
807 .property = "max_revision",\
808 .value = "0",\
809 },{\
810 .driver = "vhost-scsi-ccw",\
811 .property = "max_revision",\
812 .value = "0",\
813 },
814
815 static void ccw_machine_2_13_instance_options(MachineState *machine)
816 {
817 }
818
819 static void ccw_machine_2_13_class_options(MachineClass *mc)
820 {
821 }
822 DEFINE_CCW_MACHINE(2_13, "2.13", true);
823
824 static void ccw_machine_2_12_instance_options(MachineState *machine)
825 {
826 ccw_machine_2_13_instance_options(machine);
827 }
828
829 static void ccw_machine_2_12_class_options(MachineClass *mc)
830 {
831 ccw_machine_2_13_class_options(mc);
832 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_12);
833 }
834 DEFINE_CCW_MACHINE(2_12, "2.12", false);
835
836 static void ccw_machine_2_11_instance_options(MachineState *machine)
837 {
838 static const S390FeatInit qemu_cpu_feat = { S390_FEAT_LIST_QEMU_V2_11 };
839 ccw_machine_2_12_instance_options(machine);
840
841 /* before 2.12 we emulated the very first z900 */
842 s390_set_qemu_cpu_model(0x2064, 7, 1, qemu_cpu_feat);
843 }
844
845 static void ccw_machine_2_11_class_options(MachineClass *mc)
846 {
847 ccw_machine_2_12_class_options(mc);
848 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_11);
849 }
850 DEFINE_CCW_MACHINE(2_11, "2.11", false);
851
852 static void ccw_machine_2_10_instance_options(MachineState *machine)
853 {
854 ccw_machine_2_11_instance_options(machine);
855 }
856
857 static void ccw_machine_2_10_class_options(MachineClass *mc)
858 {
859 ccw_machine_2_11_class_options(mc);
860 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_10);
861 }
862 DEFINE_CCW_MACHINE(2_10, "2.10", false);
863
864 static void ccw_machine_2_9_instance_options(MachineState *machine)
865 {
866 ccw_machine_2_10_instance_options(machine);
867 s390_cpudef_featoff_greater(12, 1, S390_FEAT_ESOP);
868 s390_cpudef_featoff_greater(12, 1, S390_FEAT_SIDE_EFFECT_ACCESS_ESOP2);
869 s390_cpudef_featoff_greater(12, 1, S390_FEAT_ZPCI);
870 s390_cpudef_featoff_greater(12, 1, S390_FEAT_ADAPTER_INT_SUPPRESSION);
871 s390_cpudef_featoff_greater(12, 1, S390_FEAT_ADAPTER_EVENT_NOTIFICATION);
872 }
873
874 static void ccw_machine_2_9_class_options(MachineClass *mc)
875 {
876 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
877
878 ccw_machine_2_10_class_options(mc);
879 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_9);
880 s390mc->css_migration_enabled = false;
881 }
882 DEFINE_CCW_MACHINE(2_9, "2.9", false);
883
884 static void ccw_machine_2_8_instance_options(MachineState *machine)
885 {
886 ccw_machine_2_9_instance_options(machine);
887 }
888
889 static void ccw_machine_2_8_class_options(MachineClass *mc)
890 {
891 ccw_machine_2_9_class_options(mc);
892 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_8);
893 }
894 DEFINE_CCW_MACHINE(2_8, "2.8", false);
895
896 static void ccw_machine_2_7_instance_options(MachineState *machine)
897 {
898 ccw_machine_2_8_instance_options(machine);
899 }
900
901 static void ccw_machine_2_7_class_options(MachineClass *mc)
902 {
903 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
904
905 s390mc->cpu_model_allowed = false;
906 ccw_machine_2_8_class_options(mc);
907 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_7);
908 }
909 DEFINE_CCW_MACHINE(2_7, "2.7", false);
910
911 static void ccw_machine_2_6_instance_options(MachineState *machine)
912 {
913 ccw_machine_2_7_instance_options(machine);
914 }
915
916 static void ccw_machine_2_6_class_options(MachineClass *mc)
917 {
918 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
919
920 s390mc->ri_allowed = false;
921 ccw_machine_2_7_class_options(mc);
922 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_6);
923 }
924 DEFINE_CCW_MACHINE(2_6, "2.6", false);
925
926 static void ccw_machine_2_5_instance_options(MachineState *machine)
927 {
928 ccw_machine_2_6_instance_options(machine);
929 }
930
931 static void ccw_machine_2_5_class_options(MachineClass *mc)
932 {
933 ccw_machine_2_6_class_options(mc);
934 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_5);
935 }
936 DEFINE_CCW_MACHINE(2_5, "2.5", false);
937
938 static void ccw_machine_2_4_instance_options(MachineState *machine)
939 {
940 ccw_machine_2_5_instance_options(machine);
941 }
942
943 static void ccw_machine_2_4_class_options(MachineClass *mc)
944 {
945 ccw_machine_2_5_class_options(mc);
946 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_4);
947 }
948 DEFINE_CCW_MACHINE(2_4, "2.4", false);
949
950 static void ccw_machine_register_types(void)
951 {
952 type_register_static(&ccw_machine_info);
953 }
954
955 type_init(ccw_machine_register_types)