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) 569