hw/s390x/s390-virtio-ccw.c

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