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_CCW_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 /* get a BUS */ 117 css_bus = virtual_css_bus_init(); 118 s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline, 119 machine->initrd_filename, "s390-ccw.img", true); 120 s390_flic_init(); 121 122 dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE); 123 object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE, 124 OBJECT(dev), NULL); 125 qdev_init_nofail(dev); 126 127 /* register hypercalls */ 128 virtio_ccw_register_hcalls(); 129 130 /* init CPUs */ 131 s390_init_cpus(machine); 132 133 if (kvm_enabled()) { 134 kvm_s390_enable_css_support(s390_cpu_addr2state(0)); 135 } 136 /* 137 * Create virtual css and set it as default so that non mcss-e 138 * enabled guests only see virtio devices. 139 */ 140 ret = css_create_css_image(VIRTUAL_CSSID, true); 141 assert(ret == 0); 142 143 /* Create VirtIO network adapters */ 144 s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw"); 145 146 /* Register savevm handler for guest TOD clock */ 147 register_savevm(NULL, "todclock", 0, 1, 148 gtod_save, gtod_load, kvm_state); 149 } 150 151 static void s390_cpu_plug(HotplugHandler *hotplug_dev, 152 DeviceState *dev, Error **errp) 153 { 154 gchar *name; 155 S390CPU *cpu = S390_CPU(dev); 156 CPUState *cs = CPU(dev); 157 158 name = g_strdup_printf("cpu[%i]", cpu->env.cpu_num); 159 object_property_set_link(OBJECT(hotplug_dev), OBJECT(cs), name, 160 errp); 161 g_free(name); 162 } 163 164 static void s390_machine_device_plug(HotplugHandler *hotplug_dev, 165 DeviceState *dev, Error **errp) 166 { 167 if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) { 168 s390_cpu_plug(hotplug_dev, dev, errp); 169 } 170 } 171 172 static HotplugHandler *s390_get_hotplug_handler(MachineState *machine, 173 DeviceState *dev) 174 { 175 if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) { 176 return HOTPLUG_HANDLER(machine); 177 } 178 return NULL; 179 } 180 181 static void s390_hot_add_cpu(const int64_t id, Error **errp) 182 { 183 MachineState *machine = MACHINE(qdev_get_machine()); 184 185 s390x_new_cpu(machine->cpu_model, id, errp); 186 } 187 188 static void ccw_machine_class_init(ObjectClass *oc, void *data) 189 { 190 MachineClass *mc = MACHINE_CLASS(oc); 191 NMIClass *nc = NMI_CLASS(oc); 192 HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 193 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); 194 195 s390mc->ri_allowed = true; 196 mc->init = ccw_init; 197 mc->reset = s390_machine_reset; 198 mc->hot_add_cpu = s390_hot_add_cpu; 199 mc->block_default_type = IF_VIRTIO; 200 mc->no_cdrom = 1; 201 mc->no_floppy = 1; 202 mc->no_serial = 1; 203 mc->no_parallel = 1; 204 mc->no_sdcard = 1; 205 mc->use_sclp = 1; 206 mc->max_cpus = 248; 207 mc->get_hotplug_handler = s390_get_hotplug_handler; 208 hc->plug = s390_machine_device_plug; 209 nc->nmi_monitor_handler = s390_nmi; 210 } 211 212 static inline bool machine_get_aes_key_wrap(Object *obj, Error **errp) 213 { 214 S390CcwMachineState *ms = S390_CCW_MACHINE(obj); 215 216 return ms->aes_key_wrap; 217 } 218 219 static inline void machine_set_aes_key_wrap(Object *obj, bool value, 220 Error **errp) 221 { 222 S390CcwMachineState *ms = S390_CCW_MACHINE(obj); 223 224 ms->aes_key_wrap = value; 225 } 226 227 static inline bool machine_get_dea_key_wrap(Object *obj, Error **errp) 228 { 229 S390CcwMachineState *ms = S390_CCW_MACHINE(obj); 230 231 return ms->dea_key_wrap; 232 } 233 234 static inline void machine_set_dea_key_wrap(Object *obj, bool value, 235 Error **errp) 236 { 237 S390CcwMachineState *ms = S390_CCW_MACHINE(obj); 238 239 ms->dea_key_wrap = value; 240 } 241 242 bool ri_allowed(void) 243 { 244 if (kvm_enabled()) { 245 MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine()); 246 if (object_class_dynamic_cast(OBJECT_CLASS(mc), 247 TYPE_S390_CCW_MACHINE)) { 248 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); 249 250 return s390mc->ri_allowed; 251 } 252 /* 253 * Make sure the "none" machine can have ri, otherwise it won't * be 254 * unlocked in KVM and therefore the host CPU model might be wrong. 255 */ 256 return true; 257 } 258 return 0; 259 } 260 261 static inline void s390_machine_initfn(Object *obj) 262 { 263 object_property_add_bool(obj, "aes-key-wrap", 264 machine_get_aes_key_wrap, 265 machine_set_aes_key_wrap, NULL); 266 object_property_set_description(obj, "aes-key-wrap", 267 "enable/disable AES key wrapping using the CPACF wrapping key", 268 NULL); 269 object_property_set_bool(obj, true, "aes-key-wrap", NULL); 270 271 object_property_add_bool(obj, "dea-key-wrap", 272 machine_get_dea_key_wrap, 273 machine_set_dea_key_wrap, NULL); 274 object_property_set_description(obj, "dea-key-wrap", 275 "enable/disable DEA key wrapping using the CPACF wrapping key", 276 NULL); 277 object_property_set_bool(obj, true, "dea-key-wrap", NULL); 278 } 279 280 static const TypeInfo ccw_machine_info = { 281 .name = TYPE_S390_CCW_MACHINE, 282 .parent = TYPE_MACHINE, 283 .abstract = true, 284 .instance_size = sizeof(S390CcwMachineState), 285 .instance_init = s390_machine_initfn, 286 .class_size = sizeof(S390CcwMachineClass), 287 .class_init = ccw_machine_class_init, 288 .interfaces = (InterfaceInfo[]) { 289 { TYPE_NMI }, 290 { TYPE_HOTPLUG_HANDLER}, 291 { } 292 }, 293 }; 294 295 #define DEFINE_CCW_MACHINE(suffix, verstr, latest) \ 296 static void ccw_machine_##suffix##_class_init(ObjectClass *oc, \ 297 void *data) \ 298 { \ 299 MachineClass *mc = MACHINE_CLASS(oc); \ 300 ccw_machine_##suffix##_class_options(mc); \ 301 mc->desc = "VirtIO-ccw based S390 machine v" verstr; \ 302 if (latest) { \ 303 mc->alias = "s390-ccw-virtio"; \ 304 mc->is_default = 1; \ 305 } \ 306 } \ 307 static void ccw_machine_##suffix##_instance_init(Object *obj) \ 308 { \ 309 MachineState *machine = MACHINE(obj); \ 310 ccw_machine_##suffix##_instance_options(machine); \ 311 } \ 312 static const TypeInfo ccw_machine_##suffix##_info = { \ 313 .name = MACHINE_TYPE_NAME("s390-ccw-virtio-" verstr), \ 314 .parent = TYPE_S390_CCW_MACHINE, \ 315 .class_init = ccw_machine_##suffix##_class_init, \ 316 .instance_init = ccw_machine_##suffix##_instance_init, \ 317 }; \ 318 static void ccw_machine_register_##suffix(void) \ 319 { \ 320 type_register_static(&ccw_machine_##suffix##_info); \ 321 } \ 322 type_init(ccw_machine_register_##suffix) 323 324 #define CCW_COMPAT_2_7 \ 325 HW_COMPAT_2_7 326 327 #define CCW_COMPAT_2_6 \ 328 CCW_COMPAT_2_7 \ 329 HW_COMPAT_2_6 \ 330 {\ 331 .driver = TYPE_S390_IPL,\ 332 .property = "iplbext_migration",\ 333 .value = "off",\ 334 }, {\ 335 .driver = TYPE_VIRTUAL_CSS_BRIDGE,\ 336 .property = "css_dev_path",\ 337 .value = "off",\ 338 }, 339 340 #define CCW_COMPAT_2_5 \ 341 CCW_COMPAT_2_6 \ 342 HW_COMPAT_2_5 343 344 #define CCW_COMPAT_2_4 \ 345 HW_COMPAT_2_4 \ 346 {\ 347 .driver = TYPE_S390_SKEYS,\ 348 .property = "migration-enabled",\ 349 .value = "off",\ 350 },{\ 351 .driver = "virtio-blk-ccw",\ 352 .property = "max_revision",\ 353 .value = "0",\ 354 },{\ 355 .driver = "virtio-balloon-ccw",\ 356 .property = "max_revision",\ 357 .value = "0",\ 358 },{\ 359 .driver = "virtio-serial-ccw",\ 360 .property = "max_revision",\ 361 .value = "0",\ 362 },{\ 363 .driver = "virtio-9p-ccw",\ 364 .property = "max_revision",\ 365 .value = "0",\ 366 },{\ 367 .driver = "virtio-rng-ccw",\ 368 .property = "max_revision",\ 369 .value = "0",\ 370 },{\ 371 .driver = "virtio-net-ccw",\ 372 .property = "max_revision",\ 373 .value = "0",\ 374 },{\ 375 .driver = "virtio-scsi-ccw",\ 376 .property = "max_revision",\ 377 .value = "0",\ 378 },{\ 379 .driver = "vhost-scsi-ccw",\ 380 .property = "max_revision",\ 381 .value = "0",\ 382 }, 383 384 static void ccw_machine_2_8_instance_options(MachineState *machine) 385 { 386 } 387 388 static void ccw_machine_2_8_class_options(MachineClass *mc) 389 { 390 } 391 DEFINE_CCW_MACHINE(2_8, "2.8", true); 392 393 static void ccw_machine_2_7_instance_options(MachineState *machine) 394 { 395 ccw_machine_2_8_instance_options(machine); 396 } 397 398 static void ccw_machine_2_7_class_options(MachineClass *mc) 399 { 400 ccw_machine_2_8_class_options(mc); 401 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_7); 402 } 403 DEFINE_CCW_MACHINE(2_7, "2.7", false); 404 405 static void ccw_machine_2_6_instance_options(MachineState *machine) 406 { 407 ccw_machine_2_7_instance_options(machine); 408 } 409 410 static void ccw_machine_2_6_class_options(MachineClass *mc) 411 { 412 S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc); 413 414 s390mc->ri_allowed = false; 415 ccw_machine_2_7_class_options(mc); 416 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_6); 417 } 418 DEFINE_CCW_MACHINE(2_6, "2.6", false); 419 420 static void ccw_machine_2_5_instance_options(MachineState *machine) 421 { 422 ccw_machine_2_6_instance_options(machine); 423 } 424 425 static void ccw_machine_2_5_class_options(MachineClass *mc) 426 { 427 ccw_machine_2_6_class_options(mc); 428 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_5); 429 } 430 DEFINE_CCW_MACHINE(2_5, "2.5", false); 431 432 static void ccw_machine_2_4_instance_options(MachineState *machine) 433 { 434 ccw_machine_2_5_instance_options(machine); 435 } 436 437 static void ccw_machine_2_4_class_options(MachineClass *mc) 438 { 439 ccw_machine_2_5_class_options(mc); 440 SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_4); 441 } 442 DEFINE_CCW_MACHINE(2_4, "2.4", false); 443 444 static void ccw_machine_register_types(void) 445 { 446 type_register_static(&ccw_machine_info); 447 } 448 449 type_init(ccw_machine_register_types) 450