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