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_3_0_instance_options(MachineState *machine) 816 { 817 } 818 819 static void ccw_machine_3_0_class_options(MachineClass *mc) 820 { 821 } 822 DEFINE_CCW_MACHINE(3_0, "3.0", true); 823 824 static void ccw_machine_2_12_instance_options(MachineState *machine) 825 { 826 ccw_machine_3_0_instance_options(machine); 827 } 828 829 static void ccw_machine_2_12_class_options(MachineClass *mc) 830 { 831 ccw_machine_3_0_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) 956