hw/s390x/s390-virtio-ccw.c

   1 /*
   2  * virtio ccw machine
   3  *
   4  * Copyright 2012 IBM Corp.
   5  * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
   6  *
   7  * This work is licensed under the terms of the GNU GPL, version 2 or (at
   8  * your option) any later version. See the COPYING file in the top-level
   9  * directory.
  10  */
  11
  12 #include "qemu/osdep.h"
  13 #include "qapi/error.h"
  14 #include "qemu-common.h"
  15 #include "cpu.h"
  16 #include "hw/boards.h"
  17 #include "exec/address-spaces.h"
  18 #include "s390-virtio.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 "s390-pci-bus.h"
  26 #include "hw/s390x/storage-keys.h"
  27 #include "hw/compat.h"
  28 #include "ipl.h"
  29 #include "hw/s390x/s390-virtio-ccw.h"
  30 #include "hw/s390x/css-bridge.h"
  31
  32 static const char *const reset_dev_types[] = {
  33     TYPE_VIRTUAL_CSS_BRIDGE,
  34     "s390-sclp-event-facility",
  35     "s390-flic",
  36     "diag288",
  37 };
  38
  39 void subsystem_reset(void)
  40 {
  41     DeviceState *dev;
  42     int i;
  43
  44     for (i = 0; i < ARRAY_SIZE(reset_dev_types); i++) {
  45         dev = DEVICE(object_resolve_path_type("", reset_dev_types[i], NULL));
  46         if (dev) {
  47             qdev_reset_all(dev);
  48         }
  49     }
  50 }
  51
  52 static int virtio_ccw_hcall_notify(const uint64_t *args)
  53 {
  54     uint64_t subch_id = args[0];
  55     uint64_t queue = args[1];
  56     SubchDev *sch;
  57     int cssid, ssid, schid, m;
  58
  59     if (ioinst_disassemble_sch_ident(subch_id, &m, &cssid, &ssid, &schid)) {
  60         return -EINVAL;
  61     }
  62     sch = css_find_subch(m, cssid, ssid, schid);
  63     if (!sch || !css_subch_visible(sch)) {
  64         return -EINVAL;
  65     }
  66     if (queue >= VIRTIO_QUEUE_MAX) {
  67         return -EINVAL;
  68     }
  69     virtio_queue_notify(virtio_ccw_get_vdev(sch), queue);
  70     return 0;
  71
  72 }
  73
  74 static int virtio_ccw_hcall_early_printk(const uint64_t *args)
  75 {
  76     uint64_t mem = args[0];
  77
  78     if (mem < ram_size) {
  79         /* Early printk */
  80         return 0;
  81     }
  82     return -EINVAL;
  83 }
  84
  85 static void virtio_ccw_register_hcalls(void)
  86 {
  87     s390_register_virtio_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY,
  88                                    virtio_ccw_hcall_notify);
  89     /* Tolerate early printk. */
  90     s390_register_virtio_hypercall(KVM_S390_VIRTIO_NOTIFY,
  91                                    virtio_ccw_hcall_early_printk);
  92 }
  93
  94 void s390_memory_init(ram_addr_t mem_size)
  95 {
  96     MemoryRegion *sysmem = get_system_memory();
  97     MemoryRegion *ram = g_new(MemoryRegion, 1);
  98
  99     /* allocate RAM for core */
 100     memory_region_allocate_system_memory(ram, NULL, "s390.ram", mem_size);
 101     memory_region_add_subregion(sysmem, 0, ram);
 102
 103     /* Initialize storage key device */
 104     s390_skeys_init();
 105 }
 106
 107 static SaveVMHandlers savevm_gtod = {
 108     .save_state = gtod_save,
 109     .load_state = gtod_load,
 110 };
 111
 112 static void ccw_init(MachineState *machine)
 113 {
 114     int ret;
 115     VirtualCssBus *css_bus;
 116     DeviceState *dev;
 117
 118     s390_sclp_init();
 119     s390_memory_init(machine->ram_size);
 120
 121     s390_flic_init();
 122
 123     /* get a BUS */
 124     css_bus = virtual_css_bus_init();
 125     s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline,
 126                       machine->initrd_filename, "s390-ccw.img",
 127                       "s390-netboot.img", true);
 128
 129     dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE);
 130     object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE,
 131                               OBJECT(dev), NULL);
 132     qdev_init_nofail(dev);
 133
 134     /* register hypercalls */
 135     virtio_ccw_register_hcalls();
 136
 137     /* init CPUs */
 138     s390_init_cpus(machine);
 139
 140     if (kvm_enabled()) {
 141         kvm_s390_enable_css_support(s390_cpu_addr2state(0));
 142     }
 143     /*
 144      * Non mcss-e enabled guests only see the devices from the default
 145      * css, which is determined by the value of the squash_mcss property.
 146      * Note: we must not squash non virtual devices to css 0xFE.
 147      */
 148     if (css_bus->squash_mcss) {
 149         ret = css_create_css_image(0, true);
 150     } else {
 151         ret = css_create_css_image(VIRTUAL_CSSID, true);
 152     }
 153     assert(ret == 0);
 154
 155     /* Create VirtIO network adapters */
 156     s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw");
 157
 158     /* Register savevm handler for guest TOD clock */
 159     register_savevm_live(NULL, "todclock", 0, 1, &savevm_gtod, kvm_state);
 160 }
 161
 162 static void s390_cpu_plug(HotplugHandler *hotplug_dev,
 163                         DeviceState *dev, Error **errp)
 164 {
 165     gchar *name;
 166     S390CPU *cpu = S390_CPU(dev);
 167     CPUState *cs = CPU(dev);
 168
 169     name = g_strdup_printf("cpu[%i]", cpu->env.cpu_num);
 170     object_property_set_link(OBJECT(hotplug_dev), OBJECT(cs), name,
 171                              errp);
 172     g_free(name);
 173 }
 174
 175 static void s390_machine_device_plug(HotplugHandler *hotplug_dev,
 176                                      DeviceState *dev, Error **errp)
 177 {
 178     if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
 179         s390_cpu_plug(hotplug_dev, dev, errp);
 180     }
 181 }
 182
 183 static HotplugHandler *s390_get_hotplug_handler(MachineState *machine,
 184                                                 DeviceState *dev)
 185 {
 186     if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
 187         return HOTPLUG_HANDLER(machine);
 188     }
 189     return NULL;
 190 }
 191
 192 static void s390_hot_add_cpu(const int64_t id, Error **errp)
 193 {
 194     MachineState *machine = MACHINE(qdev_get_machine());
 195
 196     s390x_new_cpu(machine->cpu_model, id, errp);
 197 }
 198
 199 static void ccw_machine_class_init(ObjectClass *oc, void *data)
 200 {
 201     MachineClass *mc = MACHINE_CLASS(oc);
 202     NMIClass *nc = NMI_CLASS(oc);
 203     HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
 204     S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
 205
 206     s390mc->ri_allowed = true;
 207     s390mc->cpu_model_allowed = true;
 208     mc->init = ccw_init;
 209     mc->reset = s390_machine_reset;
 210     mc->hot_add_cpu = s390_hot_add_cpu;
 211     mc->block_default_type = IF_VIRTIO;
 212     mc->no_cdrom = 1;
 213     mc->no_floppy = 1;
 214     mc->no_serial = 1;
 215     mc->no_parallel = 1;
 216     mc->no_sdcard = 1;
 217     mc->use_sclp = 1;
 218     mc->max_cpus = 248;
 219     mc->get_hotplug_handler = s390_get_hotplug_handler;
 220     hc->plug = s390_machine_device_plug;
 221     nc->nmi_monitor_handler = s390_nmi;
 222 }
 223
 224 static inline bool machine_get_aes_key_wrap(Object *obj, Error **errp)
 225 {
 226     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 227
 228     return ms->aes_key_wrap;
 229 }
 230
 231 static inline void machine_set_aes_key_wrap(Object *obj, bool value,
 232                                             Error **errp)
 233 {
 234     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 235
 236     ms->aes_key_wrap = value;
 237 }
 238
 239 static inline bool machine_get_dea_key_wrap(Object *obj, Error **errp)
 240 {
 241     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 242
 243     return ms->dea_key_wrap;
 244 }
 245
 246 static inline void machine_set_dea_key_wrap(Object *obj, bool value,
 247                                             Error **errp)
 248 {
 249     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 250
 251     ms->dea_key_wrap = value;
 252 }
 253
 254 bool ri_allowed(void)
 255 {
 256     if (kvm_enabled()) {
 257         MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
 258         if (object_class_dynamic_cast(OBJECT_CLASS(mc),
 259                                       TYPE_S390_CCW_MACHINE)) {
 260             S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
 261
 262             return s390mc->ri_allowed;
 263         }
 264         /*
 265          * Make sure the "none" machine can have ri, otherwise it won't * be
 266          * unlocked in KVM and therefore the host CPU model might be wrong.
 267          */
 268         return true;
 269     }
 270     return 0;
 271 }
 272
 273 bool cpu_model_allowed(void)
 274 {
 275     MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
 276     if (object_class_dynamic_cast(OBJECT_CLASS(mc),
 277                                   TYPE_S390_CCW_MACHINE)) {
 278         S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
 279
 280         return s390mc->cpu_model_allowed;
 281     }
 282     /* allow CPU model qmp queries with the "none" machine */
 283     return true;
 284 }
 285
 286 static char *machine_get_loadparm(Object *obj, Error **errp)
 287 {
 288     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 289
 290     return g_memdup(ms->loadparm, sizeof(ms->loadparm));
 291 }
 292
 293 static void machine_set_loadparm(Object *obj, const char *val, Error **errp)
 294 {
 295     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 296     int i;
 297
 298     for (i = 0; i < sizeof(ms->loadparm) && val[i]; i++) {
 299         uint8_t c = toupper(val[i]); /* mimic HMC */
 300
 301         if (('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || (c == '.') ||
 302             (c == ' ')) {
 303             ms->loadparm[i] = c;
 304         } else {
 305             error_setg(errp, "LOADPARM: invalid character '%c' (ASCII 0x%02x)",
 306                        c, c);
 307             return;
 308         }
 309     }
 310
 311     for (; i < sizeof(ms->loadparm); i++) {
 312         ms->loadparm[i] = ' '; /* pad right with spaces */
 313     }
 314 }
 315 static inline bool machine_get_squash_mcss(Object *obj, Error **errp)
 316 {
 317     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 318
 319     return ms->s390_squash_mcss;
 320 }
 321
 322 static inline void machine_set_squash_mcss(Object *obj, bool value,
 323                                            Error **errp)
 324 {
 325     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 326
 327     ms->s390_squash_mcss = value;
 328 }
 329
 330 static inline void s390_machine_initfn(Object *obj)
 331 {
 332     object_property_add_bool(obj, "aes-key-wrap",
 333                              machine_get_aes_key_wrap,
 334                              machine_set_aes_key_wrap, NULL);
 335     object_property_set_description(obj, "aes-key-wrap",
 336             "enable/disable AES key wrapping using the CPACF wrapping key",
 337             NULL);
 338     object_property_set_bool(obj, true, "aes-key-wrap", NULL);
 339
 340     object_property_add_bool(obj, "dea-key-wrap",
 341                              machine_get_dea_key_wrap,
 342                              machine_set_dea_key_wrap, NULL);
 343     object_property_set_description(obj, "dea-key-wrap",
 344             "enable/disable DEA key wrapping using the CPACF wrapping key",
 345             NULL);
 346     object_property_set_bool(obj, true, "dea-key-wrap", NULL);
 347     object_property_add_str(obj, "loadparm",
 348             machine_get_loadparm, machine_set_loadparm, NULL);
 349     object_property_set_description(obj, "loadparm",
 350             "Up to 8 chars in set of [A-Za-z0-9. ] (lower case chars converted"
 351             " to upper case) to pass to machine loader, boot manager,"
 352             " and guest kernel",
 353             NULL);
 354     object_property_add_bool(obj, "s390-squash-mcss",
 355                              machine_get_squash_mcss,
 356                              machine_set_squash_mcss, NULL);
 357     object_property_set_description(obj, "s390-squash-mcss",
 358             "enable/disable squashing subchannels into the default css",
 359             NULL);
 360     object_property_set_bool(obj, false, "s390-squash-mcss", NULL);
 361 }
 362
 363 static const TypeInfo ccw_machine_info = {
 364     .name          = TYPE_S390_CCW_MACHINE,
 365     .parent        = TYPE_MACHINE,
 366     .abstract      = true,
 367     .instance_size = sizeof(S390CcwMachineState),
 368     .instance_init = s390_machine_initfn,
 369     .class_size = sizeof(S390CcwMachineClass),
 370     .class_init    = ccw_machine_class_init,
 371     .interfaces = (InterfaceInfo[]) {
 372         { TYPE_NMI },
 373         { TYPE_HOTPLUG_HANDLER},
 374         { }
 375     },
 376 };
 377
 378 #define DEFINE_CCW_MACHINE(suffix, verstr, latest)                            \
 379     static void ccw_machine_##suffix##_class_init(ObjectClass *oc,            \
 380                                                   void *data)                 \
 381     {                                                                         \
 382         MachineClass *mc = MACHINE_CLASS(oc);                                 \
 383         ccw_machine_##suffix##_class_options(mc);                             \
 384         mc->desc = "VirtIO-ccw based S390 machine v" verstr;                  \
 385         if (latest) {                                                         \
 386             mc->alias = "s390-ccw-virtio";                                    \
 387             mc->is_default = 1;                                               \
 388         }                                                                     \
 389     }                                                                         \
 390     static void ccw_machine_##suffix##_instance_init(Object *obj)             \
 391     {                                                                         \
 392         MachineState *machine = MACHINE(obj);                                 \
 393         ccw_machine_##suffix##_instance_options(machine);                     \
 394     }                                                                         \
 395     static const TypeInfo ccw_machine_##suffix##_info = {                     \
 396         .name = MACHINE_TYPE_NAME("s390-ccw-virtio-" verstr),                 \
 397         .parent = TYPE_S390_CCW_MACHINE,                                      \
 398         .class_init = ccw_machine_##suffix##_class_init,                      \
 399         .instance_init = ccw_machine_##suffix##_instance_init,                \
 400     };                                                                        \
 401     static void ccw_machine_register_##suffix(void)                           \
 402     {                                                                         \
 403         type_register_static(&ccw_machine_##suffix##_info);                   \
 404     }                                                                         \
 405     type_init(ccw_machine_register_##suffix)
 406
 407 #define CCW_COMPAT_2_9 \
 408         HW_COMPAT_2_9
 409
 410 #define CCW_COMPAT_2_8 \
 411         HW_COMPAT_2_8 \
 412         {\
 413             .driver   = TYPE_S390_FLIC_COMMON,\
 414             .property = "adapter_routes_max_batch",\
 415             .value    = "64",\
 416         },
 417
 418 #define CCW_COMPAT_2_7 \
 419         HW_COMPAT_2_7
 420
 421 #define CCW_COMPAT_2_6 \
 422         HW_COMPAT_2_6 \
 423         {\
 424             .driver   = TYPE_S390_IPL,\
 425             .property = "iplbext_migration",\
 426             .value    = "off",\
 427         }, {\
 428             .driver   = TYPE_VIRTUAL_CSS_BRIDGE,\
 429             .property = "css_dev_path",\
 430             .value    = "off",\
 431         },
 432
 433 #define CCW_COMPAT_2_5 \
 434         HW_COMPAT_2_5
 435
 436 #define CCW_COMPAT_2_4 \
 437         HW_COMPAT_2_4 \
 438         {\
 439             .driver   = TYPE_S390_SKEYS,\
 440             .property = "migration-enabled",\
 441             .value    = "off",\
 442         },{\
 443             .driver   = "virtio-blk-ccw",\
 444             .property = "max_revision",\
 445             .value    = "0",\
 446         },{\
 447             .driver   = "virtio-balloon-ccw",\
 448             .property = "max_revision",\
 449             .value    = "0",\
 450         },{\
 451             .driver   = "virtio-serial-ccw",\
 452             .property = "max_revision",\
 453             .value    = "0",\
 454         },{\
 455             .driver   = "virtio-9p-ccw",\
 456             .property = "max_revision",\
 457             .value    = "0",\
 458         },{\
 459             .driver   = "virtio-rng-ccw",\
 460             .property = "max_revision",\
 461             .value    = "0",\
 462         },{\
 463             .driver   = "virtio-net-ccw",\
 464             .property = "max_revision",\
 465             .value    = "0",\
 466         },{\
 467             .driver   = "virtio-scsi-ccw",\
 468             .property = "max_revision",\
 469             .value    = "0",\
 470         },{\
 471             .driver   = "vhost-scsi-ccw",\
 472             .property = "max_revision",\
 473             .value    = "0",\
 474         },
 475
 476 static void ccw_machine_2_10_instance_options(MachineState *machine)
 477 {
 478 }
 479
 480 static void ccw_machine_2_10_class_options(MachineClass *mc)
 481 {
 482 }
 483 DEFINE_CCW_MACHINE(2_10, "2.10", true);
 484
 485 static void ccw_machine_2_9_instance_options(MachineState *machine)
 486 {
 487     ccw_machine_2_10_instance_options(machine);
 488 }
 489
 490 static void ccw_machine_2_9_class_options(MachineClass *mc)
 491 {
 492     ccw_machine_2_10_class_options(mc);
 493     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_9);
 494 }
 495 DEFINE_CCW_MACHINE(2_9, "2.9", false);
 496
 497 static void ccw_machine_2_8_instance_options(MachineState *machine)
 498 {
 499     ccw_machine_2_9_instance_options(machine);
 500 }
 501
 502 static void ccw_machine_2_8_class_options(MachineClass *mc)
 503 {
 504     ccw_machine_2_9_class_options(mc);
 505     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_8);
 506 }
 507 DEFINE_CCW_MACHINE(2_8, "2.8", false);
 508
 509 static void ccw_machine_2_7_instance_options(MachineState *machine)
 510 {
 511     ccw_machine_2_8_instance_options(machine);
 512 }
 513
 514 static void ccw_machine_2_7_class_options(MachineClass *mc)
 515 {
 516     S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
 517
 518     s390mc->cpu_model_allowed = false;
 519     ccw_machine_2_8_class_options(mc);
 520     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_7);
 521 }
 522 DEFINE_CCW_MACHINE(2_7, "2.7", false);
 523
 524 static void ccw_machine_2_6_instance_options(MachineState *machine)
 525 {
 526     ccw_machine_2_7_instance_options(machine);
 527 }
 528
 529 static void ccw_machine_2_6_class_options(MachineClass *mc)
 530 {
 531     S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
 532
 533     s390mc->ri_allowed = false;
 534     ccw_machine_2_7_class_options(mc);
 535     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_6);
 536 }
 537 DEFINE_CCW_MACHINE(2_6, "2.6", false);
 538
 539 static void ccw_machine_2_5_instance_options(MachineState *machine)
 540 {
 541     ccw_machine_2_6_instance_options(machine);
 542 }
 543
 544 static void ccw_machine_2_5_class_options(MachineClass *mc)
 545 {
 546     ccw_machine_2_6_class_options(mc);
 547     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_5);
 548 }
 549 DEFINE_CCW_MACHINE(2_5, "2.5", false);
 550
 551 static void ccw_machine_2_4_instance_options(MachineState *machine)
 552 {
 553     ccw_machine_2_5_instance_options(machine);
 554 }
 555
 556 static void ccw_machine_2_4_class_options(MachineClass *mc)
 557 {
 558     ccw_machine_2_5_class_options(mc);
 559     SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_4);
 560 }
 561 DEFINE_CCW_MACHINE(2_4, "2.4", false);
 562
 563 static void ccw_machine_register_types(void)
 564 {
 565     type_register_static(&ccw_machine_info);
 566 }
 567
 568 type_init(ccw_machine_register_types)