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 void ccw_init(MachineState *machine) 108 { 109 int ret; 110 VirtualCssBus *css_bus; 111 DeviceState *dev; 112 113 s390_sclp_init(); 114 s390_memory_init(machine->ram_size); 115 116 s390_flic_init(); 117 118 /* get a BUS */ 119 css_bus = virtual_css_bus_init(); 120 s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline, 121 machine->initrd_filename, "s390-ccw.img", 122 "s390-netboot.img", true); 123 124 dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE); 125 object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE, 126 OBJECT(dev), NULL); 127 qdev_init_nofail(dev); 128 129 /* register hypercalls */ 130 virtio_ccw_register_hcalls(); 131 132 /* init CPUs */ 133 s390_init_cpus(machine); 134 135 if (kvm_enabled()) { 136 kvm_s390_enable_css_support(s390_cpu_addr2state(0)); 137 } 138 /* 139 * Create virtual css and set it as default so that non mcss-e 140 * enabled guests only see virtio devices. 141 */ 142 ret = css_create_css_image(VIRTUAL_CSSID, true); 143 assert(ret == 0); 144 145 /* Create VirtIO network adapters */ 146 s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw"); 147 148 /* Register savevm handler for guest TOD clock */ 149 register_savevm(NULL, "todclock", 0, 1, 150 gtod_save, gtod_load, kvm_state); 151 } 152 153 static void s390_cpu_plug(HotplugHandler *hotplug_dev, 154 DeviceState *dev, Error **errp) 155 { 156 gchar *name; 157 S390CPU *cpu = S390_CPU(dev); 158 CPUState *cs = CPU(dev); 159 160 name = g_strdup_printf("cpu[%i]", cpu->env.cpu_num); 161 object_property_set_link(OBJECT(hotplug_dev), OBJECT(cs), name, 162 errp); 163 g_free(name); 164 } 165 166 static void s390_machine_device_plug(HotplugHandler *hotplug_dev, 167 DeviceState *dev, Error **errp) 168 { 169 if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) { 170 s390_cpu_plug(hotplug_dev, dev, errp); 171 } 172 } 173 174 static HotplugHandler *s390_get_hotplug_handler(MachineState *machine, 175 DeviceState *dev) 176 { 177 if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) { 178 return HOTPLUG_HANDLER(machine); 179 } 180 return NULL; 181 } 182 183 static void s390_hot_add_cpu(const int64_t id, Error **errp) 184 { 185 MachineState *machine = MACHINE(qdev_get_machine()); 186 187 s390x_new_cpu(machine->cpu_model, id, errp); 188 } 189 190 static void ccw_machine_class_init(ObjectClass *oc, void *data) 191 { 192 MachineClass *mc = MACHINE_CLASS(oc); 193 NMIClass *nc = NMI_CLASS(oc); 194 HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 195 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); 196 197 s390mc->ri_allowed = true; 198 s390mc->cpu_model_allowed = true; 199 mc->init = ccw_init; 200 mc->reset = s390_machine_reset; 201 mc->hot_add_cpu = s390_hot_add_cpu; 202 mc->block_default_type = IF_VIRTIO; 203 mc->no_cdrom = 1; 204 mc->no_floppy = 1; 205 mc->no_serial = 1; 206 mc->no_parallel = 1; 207 mc->no_sdcard = 1; 208 mc->use_sclp = 1; 209 mc->max_cpus = 248; 210 mc->get_hotplug_handler = s390_get_hotplug_handler; 211 hc->plug = s390_machine_device_plug; 212 nc->nmi_monitor_handler = s390_nmi; 213 } 214 215 static inline bool machine_get_aes_key_wrap(Object *obj, Error **errp) 216 { 217 S390CcwMachineState *ms = S390_CCW_MACHINE(obj); 218 219 return ms->aes_key_wrap; 220 } 221 222 static inline void machine_set_aes_key_wrap(Object *obj, bool value, 223 Error **errp) 224 { 225 S390CcwMachineState *ms = S390_CCW_MACHINE(obj); 226 227 ms->aes_key_wrap = value; 228 } 229 230 static inline bool machine_get_dea_key_wrap(Object *obj, Error **errp) 231 { 232 S390CcwMachineState *ms = S390_CCW_MACHINE(obj); 233 234 return ms->dea_key_wrap; 235 } 236 237 static inline void machine_set_dea_key_wrap(Object *obj, bool value, 238 Error **errp) 239 { 240 S390CcwMachineState *ms = S390_CCW_MACHINE(obj); 241 242 ms->dea_key_wrap = value; 243 } 244 245 bool ri_allowed(void) 246 { 247 if (kvm_enabled()) { 248 MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 249 if (object_class_dynamic_cast(OBJECT_CLASS(mc), 250 TYPE_S390_CCW_MACHINE)) { 251 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); 252 253 return s390mc->ri_allowed; 254 } 255 /* 256 * Make sure the "none" machine can have ri, otherwise it won't * be 257 * unlocked in KVM and therefore the host CPU model might be wrong. 258 */ 259 return true; 260 } 261 return 0; 262 } 263 264 bool cpu_model_allowed(void) 265 { 266 MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 267 if (object_class_dynamic_cast(OBJECT_CLASS(mc), 268 TYPE_S390_CCW_MACHINE)) { 269 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); 270 271 return s390mc->cpu_model_allowed; 272 } 273 /* allow CPU model qmp queries with the "none" machine */ 274 return true; 275 } 276 277 static char *machine_get_loadparm(Object *obj, Error **errp) 278 { 279 S390CcwMachineState *ms = S390_CCW_MACHINE(obj); 280 281 return g_memdup(ms->loadparm, sizeof(ms->loadparm)); 282 } 283 284 static void machine_set_loadparm(Object *obj, const char *val, Error **errp) 285 { 286 S390CcwMachineState *ms = S390_CCW_MACHINE(obj); 287 int i; 288 289 for (i = 0; i < sizeof(ms->loadparm) && val[i]; i++) { 290 uint8_t c = toupper(val[i]); /* mimic HMC */ 291 292 if (('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || (c == '.') || 293 (c == ' ')) { 294 ms->loadparm[i] = c; 295 } else { 296 error_setg(errp, "LOADPARM: invalid character '%c' (ASCII 0x%02x)", 297 c, c); 298 return; 299 } 300 } 301 302 for (; i < sizeof(ms->loadparm); i++) { 303 ms->loadparm[i] = ' '; /* pad right with spaces */ 304 } 305 } 306 307 static inline void s390_machine_initfn(Object *obj) 308 { 309 object_property_add_bool(obj, "aes-key-wrap", 310 machine_get_aes_key_wrap, 311 machine_set_aes_key_wrap, NULL); 312 object_property_set_description(obj, "aes-key-wrap", 313 "enable/disable AES key wrapping using the CPACF wrapping key", 314 NULL); 315 object_property_set_bool(obj, true, "aes-key-wrap", NULL); 316 317 object_property_add_bool(obj, "dea-key-wrap", 318 machine_get_dea_key_wrap, 319 machine_set_dea_key_wrap, NULL); 320 object_property_set_description(obj, "dea-key-wrap", 321 "enable/disable DEA key wrapping using the CPACF wrapping key", 322 NULL); 323 object_property_set_bool(obj, true, "dea-key-wrap", NULL); 324 object_property_add_str(obj, "loadparm", 325 machine_get_loadparm, machine_set_loadparm, NULL); 326 object_property_set_description(obj, "loadparm", 327 "Up to 8 chars in set of [A-Za-z0-9. ] (lower case chars converted" 328 " to upper case) to pass to machine loader, boot manager," 329 " and guest kernel", 330 NULL); 331 } 332 333 static const TypeInfo ccw_machine_info = { 334 .name = TYPE_S390_CCW_MACHINE, 335 .parent = TYPE_MACHINE, 336 .abstract = true, 337 .instance_size = sizeof(S390CcwMachineState), 338 .instance_init = s390_machine_initfn, 339 .class_size = sizeof(S390CcwMachineClass), 340 .class_init = ccw_machine_class_init, 341 .interfaces = (InterfaceInfo[]) { 342 { TYPE_NMI }, 343 { TYPE_HOTPLUG_HANDLER}, 344 { } 345 }, 346 }; 347 348 #define DEFINE_CCW_MACHINE(suffix, verstr, latest) \ 349 static void ccw_machine_##suffix##_class_init(ObjectClass *oc, \ 350 void *data) \ 351 { \ 352 MachineClass *mc = MACHINE_CLASS(oc); \ 353 ccw_machine_##suffix##_class_options(mc); \ 354 mc->desc = "VirtIO-ccw based S390 machine v" verstr; \ 355 if (latest) { \ 356 mc->alias = "s390-ccw-virtio"; \ 357 mc->is_default = 1; \ 358 } \ 359 } \ 360 static void ccw_machine_##suffix##_instance_init(Object *obj) \ 361 { \ 362 MachineState *machine = MACHINE(obj); \ 363 ccw_machine_##suffix##_instance_options(machine); \ 364 } \ 365 static const TypeInfo ccw_machine_##suffix##_info = { \ 366 .name = MACHINE_TYPE_NAME("s390-ccw-virtio-" verstr), \ 367 .parent = TYPE_S390_CCW_MACHINE, \ 368 .class_init = ccw_machine_##suffix##_class_init, \ 369 .instance_init = ccw_machine_##suffix##_instance_init, \ 370 }; \ 371 static void ccw_machine_register_##suffix(void) \ 372 { \ 373 type_register_static(&ccw_machine_##suffix##_info); \ 374 } \ 375 type_init(ccw_machine_register_##suffix) 376 377 #define CCW_COMPAT_2_9 \ 378 HW_COMPAT_2_9 379 380 #define CCW_COMPAT_2_8 \ 381 HW_COMPAT_2_8 \ 382 {\ 383 .driver = TYPE_S390_FLIC_COMMON,\ 384 .property = "adapter_routes_max_batch",\ 385 .value = "64",\ 386 }, 387 388 #define CCW_COMPAT_2_7 \ 389 HW_COMPAT_2_7 390 391 #define CCW_COMPAT_2_6 \ 392 HW_COMPAT_2_6 \ 393 {\ 394 .driver = TYPE_S390_IPL,\ 395 .property = "iplbext_migration",\ 396 .value = "off",\ 397 }, {\ 398 .driver = TYPE_VIRTUAL_CSS_BRIDGE,\ 399 .property = "css_dev_path",\ 400 .value = "off",\ 401 }, 402 403 #define CCW_COMPAT_2_5 \ 404 HW_COMPAT_2_5 405 406 #define CCW_COMPAT_2_4 \ 407 HW_COMPAT_2_4 \ 408 {\ 409 .driver = TYPE_S390_SKEYS,\ 410 .property = "migration-enabled",\ 411 .value = "off",\ 412 },{\ 413 .driver = "virtio-blk-ccw",\ 414 .property = "max_revision",\ 415 .value = "0",\ 416 },{\ 417 .driver = "virtio-balloon-ccw",\ 418 .property = "max_revision",\ 419 .value = "0",\ 420 },{\ 421 .driver = "virtio-serial-ccw",\ 422 .property = "max_revision",\ 423 .value = "0",\ 424 },{\ 425 .driver = "virtio-9p-ccw",\ 426 .property = "max_revision",\ 427 .value = "0",\ 428 },{\ 429 .driver = "virtio-rng-ccw",\ 430 .property = "max_revision",\ 431 .value = "0",\ 432 },{\ 433 .driver = "virtio-net-ccw",\ 434 .property = "max_revision",\ 435 .value = "0",\ 436 },{\ 437 .driver = "virtio-scsi-ccw",\ 438 .property = "max_revision",\ 439 .value = "0",\ 440 },{\ 441 .driver = "vhost-scsi-ccw",\ 442 .property = "max_revision",\ 443 .value = "0",\ 444 }, 445 446 static void ccw_machine_2_10_instance_options(MachineState *machine) 447 { 448 } 449 450 static void ccw_machine_2_10_class_options(MachineClass *mc) 451 { 452 } 453 DEFINE_CCW_MACHINE(2_10, "2.10", true); 454 455 static void ccw_machine_2_9_instance_options(MachineState *machine) 456 { 457 ccw_machine_2_10_instance_options(machine); 458 } 459 460 static void ccw_machine_2_9_class_options(MachineClass *mc) 461 { 462 ccw_machine_2_10_class_options(mc); 463 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_9); 464 } 465 DEFINE_CCW_MACHINE(2_9, "2.9", false); 466 467 static void ccw_machine_2_8_instance_options(MachineState *machine) 468 { 469 ccw_machine_2_9_instance_options(machine); 470 } 471 472 static void ccw_machine_2_8_class_options(MachineClass *mc) 473 { 474 ccw_machine_2_9_class_options(mc); 475 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_8); 476 } 477 DEFINE_CCW_MACHINE(2_8, "2.8", false); 478 479 static void ccw_machine_2_7_instance_options(MachineState *machine) 480 { 481 ccw_machine_2_8_instance_options(machine); 482 } 483 484 static void ccw_machine_2_7_class_options(MachineClass *mc) 485 { 486 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); 487 488 s390mc->cpu_model_allowed = false; 489 ccw_machine_2_8_class_options(mc); 490 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_7); 491 } 492 DEFINE_CCW_MACHINE(2_7, "2.7", false); 493 494 static void ccw_machine_2_6_instance_options(MachineState *machine) 495 { 496 ccw_machine_2_7_instance_options(machine); 497 } 498 499 static void ccw_machine_2_6_class_options(MachineClass *mc) 500 { 501 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); 502 503 s390mc->ri_allowed = false; 504 ccw_machine_2_7_class_options(mc); 505 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_6); 506 } 507 DEFINE_CCW_MACHINE(2_6, "2.6", false); 508 509 static void ccw_machine_2_5_instance_options(MachineState *machine) 510 { 511 ccw_machine_2_6_instance_options(machine); 512 } 513 514 static void ccw_machine_2_5_class_options(MachineClass *mc) 515 { 516 ccw_machine_2_6_class_options(mc); 517 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_5); 518 } 519 DEFINE_CCW_MACHINE(2_5, "2.5", false); 520 521 static void ccw_machine_2_4_instance_options(MachineState *machine) 522 { 523 ccw_machine_2_5_instance_options(machine); 524 } 525 526 static void ccw_machine_2_4_class_options(MachineClass *mc) 527 { 528 ccw_machine_2_5_class_options(mc); 529 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_4); 530 } 531 DEFINE_CCW_MACHINE(2_4, "2.4", false); 532 533 static void ccw_machine_register_types(void) 534 { 535 type_register_static(&ccw_machine_info); 536 } 537 538 type_init(ccw_machine_register_types) 539