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 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
 250     if (kernel_filename) {
 251         qdev_prop_set_string(dev, "kernel", kernel_filename);
 252     }
 253     if (initrd_filename) {
 254         qdev_prop_set_string(dev, "initrd", initrd_filename);
 255     }
 256     qdev_prop_set_string(dev, "cmdline", kernel_cmdline);
 257     qdev_prop_set_string(dev, "firmware", firmware);
 258     qdev_prop_set_bit(dev, "enforce_bios", enforce_bios);
 259     if (!strlen(object_property_get_str(new, "netboot_fw", &error_abort))) {
 260         qdev_prop_set_string(dev, "netboot_fw", netboot_fw);
 261     }
 262     object_property_add_child(qdev_get_machine(), TYPE_S390_IPL,
 263                               new, NULL);
 264     object_unref(new);
 265     qdev_init_nofail(dev);
 266 }
 267
 268 static void s390_create_virtio_net(BusState *bus, const char *name)
 269 {
 270     int i;
 271
 272     for (i = 0; i < nb_nics; i++) {
 273         NICInfo *nd = &nd_table[i];
 274         DeviceState *dev;
 275
 276         if (!nd->model) {
 277             nd->model = g_strdup("virtio");
 278         }
 279
 280         qemu_check_nic_model(nd, "virtio");
 281
 282         dev = qdev_create(bus, name);
 283         qdev_set_nic_properties(dev, nd);
 284         qdev_init_nofail(dev);
 285     }
 286 }
 287
 288 static void ccw_init(MachineState *machine)
 289 {
 290     int ret;
 291     VirtualCssBus *css_bus;
 292     DeviceState *dev;
 293
 294     s390_sclp_init();
 295     s390_memory_init(machine->ram_size);
 296
 297     /* init CPUs (incl. CPU model) early so s390_has_feature() works */
 298     s390_init_cpus(machine);
 299
 300     s390_flic_init();
 301
 302     /* init the SIGP facility */
 303     s390_init_sigp();
 304
 305     /* get a BUS */
 306     css_bus = virtual_css_bus_init();
 307     s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline,
 308                       machine->initrd_filename, "s390-ccw.img",
 309                       "s390-netboot.img", true);
 310
 311     /*
 312      * We cannot easily make the pci host bridge conditional as older QEMUs
 313      * always created it. Doing so would break migration across QEMU versions.
 314      */
 315     dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE);
 316     object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE,
 317                               OBJECT(dev), NULL);
 318     qdev_init_nofail(dev);
 319
 320     /* register hypercalls */
 321     virtio_ccw_register_hcalls();
 322
 323     s390_enable_css_support(s390_cpu_addr2state(0));
 324     /*
 325      * Non mcss-e enabled guests only see the devices from the default
 326      * css, which is determined by the value of the squash_mcss property.
 327      */
 328     if (css_bus->squash_mcss) {
 329         ret = css_create_css_image(0, true);
 330     } else {
 331         ret = css_create_css_image(VIRTUAL_CSSID, true);
 332     }
 333     if (qemu_opt_get(qemu_get_machine_opts(), "s390-squash-mcss")) {
 334         warn_report("The machine property 's390-squash-mcss' is deprecated"
 335                     " (obsoleted by lifting the cssid restrictions).");
 336     }
 337
 338     assert(ret == 0);
 339     if (css_migration_enabled()) {
 340         css_register_vmstate();
 341     }
 342
 343     /* Create VirtIO network adapters */
 344     s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw");
 345
 346     /* Register savevm handler for guest TOD clock */
 347     register_savevm_live(NULL, "todclock", 0, 1, &savevm_gtod, NULL);
 348 }
 349
 350 static void s390_cpu_plug(HotplugHandler *hotplug_dev,
 351                         DeviceState *dev, Error **errp)
 352 {
 353     MachineState *ms = MACHINE(hotplug_dev);
 354     S390CPU *cpu = S390_CPU(dev);
 355
 356     g_assert(!ms->possible_cpus->cpus[cpu->env.core_id].cpu);
 357     ms->possible_cpus->cpus[cpu->env.core_id].cpu = OBJECT(dev);
 358
 359     if (dev->hotplugged) {
 360         raise_irq_cpu_hotplug();
 361     }
 362 }
 363
 364 static void s390_machine_reset(void)
 365 {
 366     S390CPU *ipl_cpu = S390_CPU(qemu_get_cpu(0));
 367
 368     s390_cmma_reset();
 369     qemu_devices_reset();
 370     s390_crypto_reset();
 371
 372     /* all cpus are stopped - configure and start the ipl cpu only */
 373     s390_ipl_prepare_cpu(ipl_cpu);
 374     s390_cpu_set_state(S390_CPU_STATE_OPERATING, ipl_cpu);
 375 }
 376
 377 static void s390_machine_device_plug(HotplugHandler *hotplug_dev,
 378                                      DeviceState *dev, Error **errp)
 379 {
 380     if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
 381         s390_cpu_plug(hotplug_dev, dev, errp);
 382     }
 383 }
 384
 385 static void s390_machine_device_unplug_request(HotplugHandler *hotplug_dev,
 386                                                DeviceState *dev, Error **errp)
 387 {
 388     if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
 389         error_setg(errp, "CPU hot unplug not supported on this machine");
 390         return;
 391     }
 392 }
 393
 394 static CpuInstanceProperties s390_cpu_index_to_props(MachineState *ms,
 395                                                      unsigned cpu_index)
 396 {
 397     MachineClass *mc = MACHINE_GET_CLASS(ms);
 398     const CPUArchIdList *possible_cpus = mc->possible_cpu_arch_ids(ms);
 399
 400     assert(cpu_index < possible_cpus->len);
 401     return possible_cpus->cpus[cpu_index].props;
 402 }
 403
 404 static const CPUArchIdList *s390_possible_cpu_arch_ids(MachineState *ms)
 405 {
 406     int i;
 407
 408     if (ms->possible_cpus) {
 409         g_assert(ms->possible_cpus && ms->possible_cpus->len == max_cpus);
 410         return ms->possible_cpus;
 411     }
 412
 413     ms->possible_cpus = g_malloc0(sizeof(CPUArchIdList) +
 414                                   sizeof(CPUArchId) * max_cpus);
 415     ms->possible_cpus->len = max_cpus;
 416     for (i = 0; i < ms->possible_cpus->len; i++) {
 417         ms->possible_cpus->cpus[i].type = ms->cpu_type;
 418         ms->possible_cpus->cpus[i].vcpus_count = 1;
 419         ms->possible_cpus->cpus[i].arch_id = i;
 420         ms->possible_cpus->cpus[i].props.has_core_id = true;
 421         ms->possible_cpus->cpus[i].props.core_id = i;
 422     }
 423
 424     return ms->possible_cpus;
 425 }
 426
 427 static HotplugHandler *s390_get_hotplug_handler(MachineState *machine,
 428                                                 DeviceState *dev)
 429 {
 430     if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
 431         return HOTPLUG_HANDLER(machine);
 432     }
 433     return NULL;
 434 }
 435
 436 static void s390_hot_add_cpu(const int64_t id, Error **errp)
 437 {
 438     MachineState *machine = MACHINE(qdev_get_machine());
 439     ObjectClass *oc;
 440
 441     g_assert(machine->possible_cpus->cpus[0].cpu);
 442     oc = OBJECT_CLASS(CPU_GET_CLASS(machine->possible_cpus->cpus[0].cpu));
 443
 444     s390x_new_cpu(object_class_get_name(oc), id, errp);
 445 }
 446
 447 static void s390_nmi(NMIState *n, int cpu_index, Error **errp)
 448 {
 449     CPUState *cs = qemu_get_cpu(cpu_index);
 450
 451     s390_cpu_restart(S390_CPU(cs));
 452 }
 453
 454 static void ccw_machine_class_init(ObjectClass *oc, void *data)
 455 {
 456     MachineClass *mc = MACHINE_CLASS(oc);
 457     NMIClass *nc = NMI_CLASS(oc);
 458     HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
 459     S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
 460
 461     s390mc->ri_allowed = true;
 462     s390mc->cpu_model_allowed = true;
 463     s390mc->css_migration_enabled = true;
 464     mc->init = ccw_init;
 465     mc->reset = s390_machine_reset;
 466     mc->hot_add_cpu = s390_hot_add_cpu;
 467     mc->block_default_type = IF_VIRTIO;
 468     mc->no_cdrom = 1;
 469     mc->no_floppy = 1;
 470     mc->no_serial = 1;
 471     mc->no_parallel = 1;
 472     mc->no_sdcard = 1;
 473     mc->use_sclp = 1;
 474     mc->max_cpus = S390_MAX_CPUS;
 475     mc->has_hotpluggable_cpus = true;
 476     mc->get_hotplug_handler = s390_get_hotplug_handler;
 477     mc->cpu_index_to_instance_props = s390_cpu_index_to_props;
 478     mc->possible_cpu_arch_ids = s390_possible_cpu_arch_ids;
 479     /* it is overridden with 'host' cpu *in kvm_arch_init* */
 480     mc->default_cpu_type = S390_CPU_TYPE_NAME("qemu");
 481     hc->plug = s390_machine_device_plug;
 482     hc->unplug_request = s390_machine_device_unplug_request;
 483     nc->nmi_monitor_handler = s390_nmi;
 484 }
 485
 486 static inline bool machine_get_aes_key_wrap(Object *obj, Error **errp)
 487 {
 488     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 489
 490     return ms->aes_key_wrap;
 491 }
 492
 493 static inline void machine_set_aes_key_wrap(Object *obj, bool value,
 494                                             Error **errp)
 495 {
 496     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 497
 498     ms->aes_key_wrap = value;
 499 }
 500
 501 static inline bool machine_get_dea_key_wrap(Object *obj, Error **errp)
 502 {
 503     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 504
 505     return ms->dea_key_wrap;
 506 }
 507
 508 static inline void machine_set_dea_key_wrap(Object *obj, bool value,
 509                                             Error **errp)
 510 {
 511     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 512
 513     ms->dea_key_wrap = value;
 514 }
 515
 516 static S390CcwMachineClass *current_mc;
 517
 518 static S390CcwMachineClass *get_machine_class(void)
 519 {
 520     if (unlikely(!current_mc)) {
 521         /*
 522         * No s390 ccw machine was instantiated, we are likely to
 523         * be called for the 'none' machine. The properties will
 524         * have their after-initialization values.
 525         */
 526         current_mc = S390_MACHINE_CLASS(
 527                      object_class_by_name(TYPE_S390_CCW_MACHINE));
 528     }
 529     return current_mc;
 530 }
 531
 532 bool ri_allowed(void)
 533 {
 534     /* for "none" machine this results in true */
 535     return get_machine_class()->ri_allowed;
 536 }
 537
 538 bool cpu_model_allowed(void)
 539 {
 540     /* for "none" machine this results in true */
 541     return get_machine_class()->cpu_model_allowed;
 542 }
 543
 544 static char *machine_get_loadparm(Object *obj, Error **errp)
 545 {
 546     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 547
 548     return g_memdup(ms->loadparm, sizeof(ms->loadparm));
 549 }
 550
 551 static void machine_set_loadparm(Object *obj, const char *val, Error **errp)
 552 {
 553     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 554     int i;
 555
 556     for (i = 0; i < sizeof(ms->loadparm) && val[i]; i++) {
 557         uint8_t c = qemu_toupper(val[i]); /* mimic HMC */
 558
 559         if (('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || (c == '.') ||
 560             (c == ' ')) {
 561             ms->loadparm[i] = c;
 562         } else {
 563             error_setg(errp, "LOADPARM: invalid character '%c' (ASCII 0x%02x)",
 564                        c, c);
 565             return;
 566         }
 567     }
 568
 569     for (; i < sizeof(ms->loadparm); i++) {
 570         ms->loadparm[i] = ' '; /* pad right with spaces */
 571     }
 572 }
 573 static inline bool machine_get_squash_mcss(Object *obj, Error **errp)
 574 {
 575     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 576
 577     return ms->s390_squash_mcss;
 578 }
 579
 580 static inline void machine_set_squash_mcss(Object *obj, bool value,
 581                                            Error **errp)
 582 {
 583     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 584
 585     ms->s390_squash_mcss = value;
 586 }
 587
 588 static inline void s390_machine_initfn(Object *obj)
 589 {
 590     object_property_add_bool(obj, "aes-key-wrap",
 591                              machine_get_aes_key_wrap,
 592                              machine_set_aes_key_wrap, NULL);
 593     object_property_set_description(obj, "aes-key-wrap",
 594             "enable/disable AES key wrapping using the CPACF wrapping key",
 595             NULL);
 596     object_property_set_bool(obj, true, "aes-key-wrap", NULL);
 597
 598     object_property_add_bool(obj, "dea-key-wrap",
 599                              machine_get_dea_key_wrap,
 600                              machine_set_dea_key_wrap, NULL);
 601     object_property_set_description(obj, "dea-key-wrap",
 602             "enable/disable DEA key wrapping using the CPACF wrapping key",
 603             NULL);
 604     object_property_set_bool(obj, true, "dea-key-wrap", NULL);
 605     object_property_add_str(obj, "loadparm",
 606             machine_get_loadparm, machine_set_loadparm, NULL);
 607     object_property_set_description(obj, "loadparm",
 608             "Up to 8 chars in set of [A-Za-z0-9. ] (lower case chars converted"
 609             " to upper case) to pass to machine loader, boot manager,"
 610             " and guest kernel",
 611             NULL);
 612     object_property_add_bool(obj, "s390-squash-mcss",
 613                              machine_get_squash_mcss,
 614                              machine_set_squash_mcss, NULL);
 615     object_property_set_description(obj, "s390-squash-mcss", "(deprecated) "
 616             "enable/disable squashing subchannels into the default css",
 617             NULL);
 618     object_property_set_bool(obj, false, "s390-squash-mcss", NULL);
 619 }
 620
 621 static const TypeInfo ccw_machine_info = {
 622     .name          = TYPE_S390_CCW_MACHINE,
 623     .parent        = TYPE_MACHINE,
 624     .abstract      = true,
 625     .instance_size = sizeof(S390CcwMachineState),
 626     .instance_init = s390_machine_initfn,
 627     .class_size = sizeof(S390CcwMachineClass),
 628     .class_init    = ccw_machine_class_init,
 629     .interfaces = (InterfaceInfo[]) {
 630         { TYPE_NMI },
 631         { TYPE_HOTPLUG_HANDLER},
 632         { }
 633     },
 634 };
 635
 636 bool css_migration_enabled(void)
 637 {
 638     return get_machine_class()->css_migration_enabled;
 639 }
 640
 641 #define DEFINE_CCW_MACHINE(suffix, verstr, latest)                            \
 642     static void ccw_machine_##suffix##_class_init(ObjectClass *oc,            \
 643                                                   void *data)                 \
 644     {                                                                         \
 645         MachineClass *mc = MACHINE_CLASS(oc);                                 \
 646         ccw_machine_##suffix##_class_options(mc);                             \
 647         mc->desc = "VirtIO-ccw based S390 machine v" verstr;                  \
 648         if (latest) {                                                         \
 649             mc->alias = "s390-ccw-virtio";                                    \
 650             mc->is_default = 1;                                               \
 651         }                                                                     \
 652     }                                                                         \
 653     static void ccw_machine_##suffix##_instance_init(Object *obj)             \
 654     {                                                                         \
 655         MachineState *machine = MACHINE(obj);                                 \
 656         current_mc = S390_MACHINE_CLASS(MACHINE_GET_CLASS(machine));          \
 657         ccw_machine_##suffix##_instance_options(machine);                     \
 658     }                                                                         \
 659     static const TypeInfo ccw_machine_##suffix##_info = {                     \
 660         .name = MACHINE_TYPE_NAME("s390-ccw-virtio-" verstr),                 \
 661         .parent = TYPE_S390_CCW_MACHINE,                                      \
 662         .class_init = ccw_machine_##suffix##_class_init,                      \
 663         .instance_init = ccw_machine_##suffix##_instance_init,                \
 664     };                                                                        \
 665     static void ccw_machine_register_##suffix(void)                           \
 666     {                                                                         \
 667         type_register_static(&ccw_machine_##suffix##_info);                   \
 668     }                                                                         \
 669     type_init(ccw_machine_register_##suffix)
 670
 671 #define CCW_COMPAT_2_11 \
 672         HW_COMPAT_2_11 \
 673         {\
 674             .driver   = TYPE_SCLP_EVENT_FACILITY,\
 675             .property = "allow_all_mask_sizes",\
 676             .value    = "off",\
 677         },
 678
 679 #define CCW_COMPAT_2_10 \
 680         HW_COMPAT_2_10
 681
 682 #define CCW_COMPAT_2_9 \
 683         HW_COMPAT_2_9 \
 684         {\
 685             .driver   = TYPE_S390_STATTRIB,\
 686             .property = "migration-enabled",\
 687             .value    = "off",\
 688         },
 689
 690 #define CCW_COMPAT_2_8 \
 691         HW_COMPAT_2_8 \
 692         {\
 693             .driver   = TYPE_S390_FLIC_COMMON,\
 694             .property = "adapter_routes_max_batch",\
 695             .value    = "64",\
 696         },
 697
 698 #define CCW_COMPAT_2_7 \
 699         HW_COMPAT_2_7
 700
 701 #define CCW_COMPAT_2_6 \
 702         HW_COMPAT_2_6 \
 703         {\
 704             .driver   = TYPE_S390_IPL,\
 705             .property = "iplbext_migration",\
 706             .value    = "off",\
 707         }, {\
 708             .driver   = TYPE_VIRTUAL_CSS_BRIDGE,\
 709             .property = "css_dev_path",\
 710             .value    = "off",\
 711         },
 712
 713 #define CCW_COMPAT_2_5 \
 714         HW_COMPAT_2_5
 715
 716 #define CCW_COMPAT_2_4 \
 717         HW_COMPAT_2_4 \
 718         {\
 719             .driver   = TYPE_S390_SKEYS,\
 720             .property = "migration-enabled",\
 721             .value    = "off",\
 722         },{\
 723             .driver   = "virtio-blk-ccw",\
 724             .property = "max_revision",\
 725             .value    = "0",\
 726         },{\
 727             .driver   = "virtio-balloon-ccw",\
 728             .property = "max_revision",\
 729             .value    = "0",\
 730         },{\
 731             .driver   = "virtio-serial-ccw",\
 732             .property = "max_revision",\
 733             .value    = "0",\
 734         },{\
 735             .driver   = "virtio-9p-ccw",\
 736             .property = "max_revision",\
 737             .value    = "0",\
 738         },{\
 739             .driver   = "virtio-rng-ccw",\
 740             .property = "max_revision",\
 741             .value    = "0",\
 742         },{\
 743             .driver   = "virtio-net-ccw",\
 744             .property = "max_revision",\
 745             .value    = "0",\
 746         },{\
 747             .driver   = "virtio-scsi-ccw",\
 748             .property = "max_revision",\
 749             .value    = "0",\
 750         },{\
 751             .driver   = "vhost-scsi-ccw",\
 752             .property = "max_revision",\
 753             .value    = "0",\
 754         },
 755
 756 static void ccw_machine_2_12_instance_options(MachineState *machine)
 757 {
 758 }
 759
 760 static void ccw_machine_2_12_class_options(MachineClass *mc)
 761 {
 762 }
 763 DEFINE_CCW_MACHINE(2_12, "2.12", true);
 764
 765 static void ccw_machine_2_11_instance_options(MachineState *machine)
 766 {
 767     static const S390FeatInit qemu_cpu_feat = { S390_FEAT_LIST_QEMU_V2_11 };
 768     ccw_machine_2_12_instance_options(machine);
 769
 770     /* before 2.12 we emulated the very first z900 */
 771     s390_set_qemu_cpu_model(0x2064, 7, 1, qemu_cpu_feat);
 772 }
 773
 774 static void ccw_machine_2_11_class_options(MachineClass *mc)
 775 {
 776     ccw_machine_2_12_class_options(mc);
 777     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_11);
 778 }
 779 DEFINE_CCW_MACHINE(2_11, "2.11", false);
 780
 781 static void ccw_machine_2_10_instance_options(MachineState *machine)
 782 {
 783     ccw_machine_2_11_instance_options(machine);
 784 }
 785
 786 static void ccw_machine_2_10_class_options(MachineClass *mc)
 787 {
 788     ccw_machine_2_11_class_options(mc);
 789     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_10);
 790 }
 791 DEFINE_CCW_MACHINE(2_10, "2.10", false);
 792
 793 static void ccw_machine_2_9_instance_options(MachineState *machine)
 794 {
 795     ccw_machine_2_10_instance_options(machine);
 796     s390_cpudef_featoff_greater(12, 1, S390_FEAT_ESOP);
 797     s390_cpudef_featoff_greater(12, 1, S390_FEAT_SIDE_EFFECT_ACCESS_ESOP2);
 798     s390_cpudef_featoff_greater(12, 1, S390_FEAT_ZPCI);
 799     s390_cpudef_featoff_greater(12, 1, S390_FEAT_ADAPTER_INT_SUPPRESSION);
 800     s390_cpudef_featoff_greater(12, 1, S390_FEAT_ADAPTER_EVENT_NOTIFICATION);
 801 }
 802
 803 static void ccw_machine_2_9_class_options(MachineClass *mc)
 804 {
 805     S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
 806
 807     ccw_machine_2_10_class_options(mc);
 808     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_9);
 809     s390mc->css_migration_enabled = false;
 810 }
 811 DEFINE_CCW_MACHINE(2_9, "2.9", false);
 812
 813 static void ccw_machine_2_8_instance_options(MachineState *machine)
 814 {
 815     ccw_machine_2_9_instance_options(machine);
 816 }
 817
 818 static void ccw_machine_2_8_class_options(MachineClass *mc)
 819 {
 820     ccw_machine_2_9_class_options(mc);
 821     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_8);
 822 }
 823 DEFINE_CCW_MACHINE(2_8, "2.8", false);
 824
 825 static void ccw_machine_2_7_instance_options(MachineState *machine)
 826 {
 827     ccw_machine_2_8_instance_options(machine);
 828 }
 829
 830 static void ccw_machine_2_7_class_options(MachineClass *mc)
 831 {
 832     S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
 833
 834     s390mc->cpu_model_allowed = false;
 835     ccw_machine_2_8_class_options(mc);
 836     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_7);
 837 }
 838 DEFINE_CCW_MACHINE(2_7, "2.7", false);
 839
 840 static void ccw_machine_2_6_instance_options(MachineState *machine)
 841 {
 842     ccw_machine_2_7_instance_options(machine);
 843 }
 844
 845 static void ccw_machine_2_6_class_options(MachineClass *mc)
 846 {
 847     S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
 848
 849     s390mc->ri_allowed = false;
 850     ccw_machine_2_7_class_options(mc);
 851     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_6);
 852 }
 853 DEFINE_CCW_MACHINE(2_6, "2.6", false);
 854
 855 static void ccw_machine_2_5_instance_options(MachineState *machine)
 856 {
 857     ccw_machine_2_6_instance_options(machine);
 858 }
 859
 860 static void ccw_machine_2_5_class_options(MachineClass *mc)
 861 {
 862     ccw_machine_2_6_class_options(mc);
 863     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_5);
 864 }
 865 DEFINE_CCW_MACHINE(2_5, "2.5", false);
 866
 867 static void ccw_machine_2_4_instance_options(MachineState *machine)
 868 {
 869     ccw_machine_2_5_instance_options(machine);
 870 }
 871
 872 static void ccw_machine_2_4_class_options(MachineClass *mc)
 873 {
 874     ccw_machine_2_5_class_options(mc);
 875     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_4);
 876 }
 877 DEFINE_CCW_MACHINE(2_4, "2.4", false);
 878
 879 static void ccw_machine_register_types(void)
 880 {
 881     type_register_static(&ccw_machine_info);
 882 }
 883
 884 type_init(ccw_machine_register_types)