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 #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) 570