4 * Copyright 2012 IBM Corp.
5 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
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
12 #include "qemu/osdep.h"
13 #include "qapi/error.h"
14 #include "qemu-common.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"
29 #include "hw/s390x/s390-virtio-ccw.h"
30 #include "hw/s390x/css-bridge.h"
32 static const char *const reset_dev_types
[] = {
33 TYPE_VIRTUAL_CSS_BRIDGE
,
34 "s390-sclp-event-facility",
39 void subsystem_reset(void)
44 for (i
= 0; i
< ARRAY_SIZE(reset_dev_types
); i
++) {
45 dev
= DEVICE(object_resolve_path_type("", reset_dev_types
[i
], NULL
));
52 static int virtio_ccw_hcall_notify(const uint64_t *args
)
54 uint64_t subch_id
= args
[0];
55 uint64_t queue
= args
[1];
57 int cssid
, ssid
, schid
, m
;
59 if (ioinst_disassemble_sch_ident(subch_id
, &m
, &cssid
, &ssid
, &schid
)) {
62 sch
= css_find_subch(m
, cssid
, ssid
, schid
);
63 if (!sch
|| !css_subch_visible(sch
)) {
66 if (queue
>= VIRTIO_QUEUE_MAX
) {
69 virtio_queue_notify(virtio_ccw_get_vdev(sch
), queue
);
74 static int virtio_ccw_hcall_early_printk(const uint64_t *args
)
76 uint64_t mem
= args
[0];
85 static void virtio_ccw_register_hcalls(void)
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
);
94 void s390_memory_init(ram_addr_t mem_size
)
96 MemoryRegion
*sysmem
= get_system_memory();
97 MemoryRegion
*ram
= g_new(MemoryRegion
, 1);
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
);
103 /* Initialize storage key device */
107 static void ccw_init(MachineState
*machine
)
110 VirtualCssBus
*css_bus
;
114 s390_memory_init(machine
->ram_size
);
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);
124 dev
= qdev_create(NULL
, TYPE_S390_PCI_HOST_BRIDGE
);
125 object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE
,
127 qdev_init_nofail(dev
);
129 /* register hypercalls */
130 virtio_ccw_register_hcalls();
133 s390_init_cpus(machine
);
136 kvm_s390_enable_css_support(s390_cpu_addr2state(0));
139 * Create virtual css and set it as default so that non mcss-e
140 * enabled guests only see virtio devices.
142 ret
= css_create_css_image(VIRTUAL_CSSID
, true);
145 /* Create VirtIO network adapters */
146 s390_create_virtio_net(BUS(css_bus
), "virtio-net-ccw");
148 /* Register savevm handler for guest TOD clock */
149 register_savevm(NULL
, "todclock", 0, 1,
150 gtod_save
, gtod_load
, kvm_state
);
153 static void s390_cpu_plug(HotplugHandler
*hotplug_dev
,
154 DeviceState
*dev
, Error
**errp
)
157 S390CPU
*cpu
= S390_CPU(dev
);
158 CPUState
*cs
= CPU(dev
);
160 name
= g_strdup_printf("cpu[%i]", cpu
->env
.cpu_num
);
161 object_property_set_link(OBJECT(hotplug_dev
), OBJECT(cs
), name
,
166 static void s390_machine_device_plug(HotplugHandler
*hotplug_dev
,
167 DeviceState
*dev
, Error
**errp
)
169 if (object_dynamic_cast(OBJECT(dev
), TYPE_CPU
)) {
170 s390_cpu_plug(hotplug_dev
, dev
, errp
);
174 static HotplugHandler
*s390_get_hotplug_handler(MachineState
*machine
,
177 if (object_dynamic_cast(OBJECT(dev
), TYPE_CPU
)) {
178 return HOTPLUG_HANDLER(machine
);
183 static void s390_hot_add_cpu(const int64_t id
, Error
**errp
)
185 MachineState
*machine
= MACHINE(qdev_get_machine());
187 s390x_new_cpu(machine
->cpu_model
, id
, errp
);
190 static void ccw_machine_class_init(ObjectClass
*oc
, void *data
)
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
);
197 s390mc
->ri_allowed
= true;
198 s390mc
->cpu_model_allowed
= true;
200 mc
->reset
= s390_machine_reset
;
201 mc
->hot_add_cpu
= s390_hot_add_cpu
;
202 mc
->block_default_type
= IF_VIRTIO
;
210 mc
->get_hotplug_handler
= s390_get_hotplug_handler
;
211 hc
->plug
= s390_machine_device_plug
;
212 nc
->nmi_monitor_handler
= s390_nmi
;
215 static inline bool machine_get_aes_key_wrap(Object
*obj
, Error
**errp
)
217 S390CcwMachineState
*ms
= S390_CCW_MACHINE(obj
);
219 return ms
->aes_key_wrap
;
222 static inline void machine_set_aes_key_wrap(Object
*obj
, bool value
,
225 S390CcwMachineState
*ms
= S390_CCW_MACHINE(obj
);
227 ms
->aes_key_wrap
= value
;
230 static inline bool machine_get_dea_key_wrap(Object
*obj
, Error
**errp
)
232 S390CcwMachineState
*ms
= S390_CCW_MACHINE(obj
);
234 return ms
->dea_key_wrap
;
237 static inline void machine_set_dea_key_wrap(Object
*obj
, bool value
,
240 S390CcwMachineState
*ms
= S390_CCW_MACHINE(obj
);
242 ms
->dea_key_wrap
= value
;
245 bool ri_allowed(void)
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
);
253 return s390mc
->ri_allowed
;
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.
264 bool cpu_model_allowed(void)
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
);
271 return s390mc
->cpu_model_allowed
;
273 /* allow CPU model qmp queries with the "none" machine */
277 static char *machine_get_loadparm(Object
*obj
, Error
**errp
)
279 S390CcwMachineState
*ms
= S390_CCW_MACHINE(obj
);
281 return g_memdup(ms
->loadparm
, sizeof(ms
->loadparm
));
284 static void machine_set_loadparm(Object
*obj
, const char *val
, Error
**errp
)
286 S390CcwMachineState
*ms
= S390_CCW_MACHINE(obj
);
289 for (i
= 0; i
< sizeof(ms
->loadparm
) && val
[i
]; i
++) {
290 uint8_t c
= toupper(val
[i
]); /* mimic HMC */
292 if (('A' <= c
&& c
<= 'Z') || ('0' <= c
&& c
<= '9') || (c
== '.') ||
296 error_setg(errp
, "LOADPARM: invalid character '%c' (ASCII 0x%02x)",
302 for (; i
< sizeof(ms
->loadparm
); i
++) {
303 ms
->loadparm
[i
] = ' '; /* pad right with spaces */
306 static inline bool machine_get_squash_mcss(Object
*obj
, Error
**errp
)
308 S390CcwMachineState
*ms
= S390_CCW_MACHINE(obj
);
310 return ms
->s390_squash_mcss
;
313 static inline void machine_set_squash_mcss(Object
*obj
, bool value
,
316 S390CcwMachineState
*ms
= S390_CCW_MACHINE(obj
);
318 ms
->s390_squash_mcss
= value
;
321 static inline void s390_machine_initfn(Object
*obj
)
323 object_property_add_bool(obj
, "aes-key-wrap",
324 machine_get_aes_key_wrap
,
325 machine_set_aes_key_wrap
, NULL
);
326 object_property_set_description(obj
, "aes-key-wrap",
327 "enable/disable AES key wrapping using the CPACF wrapping key",
329 object_property_set_bool(obj
, true, "aes-key-wrap", NULL
);
331 object_property_add_bool(obj
, "dea-key-wrap",
332 machine_get_dea_key_wrap
,
333 machine_set_dea_key_wrap
, NULL
);
334 object_property_set_description(obj
, "dea-key-wrap",
335 "enable/disable DEA key wrapping using the CPACF wrapping key",
337 object_property_set_bool(obj
, true, "dea-key-wrap", NULL
);
338 object_property_add_str(obj
, "loadparm",
339 machine_get_loadparm
, machine_set_loadparm
, NULL
);
340 object_property_set_description(obj
, "loadparm",
341 "Up to 8 chars in set of [A-Za-z0-9. ] (lower case chars converted"
342 " to upper case) to pass to machine loader, boot manager,"
345 object_property_add_bool(obj
, "s390-squash-mcss",
346 machine_get_squash_mcss
,
347 machine_set_squash_mcss
, NULL
);
348 object_property_set_description(obj
, "s390-squash-mcss",
349 "enable/disable squashing subchannels into the default css",
351 object_property_set_bool(obj
, false, "s390-squash-mcss", NULL
);
354 static const TypeInfo ccw_machine_info
= {
355 .name
= TYPE_S390_CCW_MACHINE
,
356 .parent
= TYPE_MACHINE
,
358 .instance_size
= sizeof(S390CcwMachineState
),
359 .instance_init
= s390_machine_initfn
,
360 .class_size
= sizeof(S390CcwMachineClass
),
361 .class_init
= ccw_machine_class_init
,
362 .interfaces
= (InterfaceInfo
[]) {
364 { TYPE_HOTPLUG_HANDLER
},
369 #define DEFINE_CCW_MACHINE(suffix, verstr, latest) \
370 static void ccw_machine_##suffix##_class_init(ObjectClass *oc, \
373 MachineClass *mc = MACHINE_CLASS(oc); \
374 ccw_machine_##suffix##_class_options(mc); \
375 mc->desc = "VirtIO-ccw based S390 machine v" verstr; \
377 mc->alias = "s390-ccw-virtio"; \
378 mc->is_default = 1; \
381 static void ccw_machine_##suffix##_instance_init(Object *obj) \
383 MachineState *machine = MACHINE(obj); \
384 ccw_machine_##suffix##_instance_options(machine); \
386 static const TypeInfo ccw_machine_##suffix##_info = { \
387 .name = MACHINE_TYPE_NAME("s390-ccw-virtio-" verstr), \
388 .parent = TYPE_S390_CCW_MACHINE, \
389 .class_init = ccw_machine_##suffix##_class_init, \
390 .instance_init = ccw_machine_##suffix##_instance_init, \
392 static void ccw_machine_register_##suffix(void) \
394 type_register_static(&ccw_machine_##suffix##_info); \
396 type_init(ccw_machine_register_##suffix)
398 #define CCW_COMPAT_2_9 \
401 #define CCW_COMPAT_2_8 \
404 .driver = TYPE_S390_FLIC_COMMON,\
405 .property = "adapter_routes_max_batch",\
409 #define CCW_COMPAT_2_7 \
412 #define CCW_COMPAT_2_6 \
415 .driver = TYPE_S390_IPL,\
416 .property = "iplbext_migration",\
419 .driver = TYPE_VIRTUAL_CSS_BRIDGE,\
420 .property = "css_dev_path",\
424 #define CCW_COMPAT_2_5 \
427 #define CCW_COMPAT_2_4 \
430 .driver = TYPE_S390_SKEYS,\
431 .property = "migration-enabled",\
434 .driver = "virtio-blk-ccw",\
435 .property = "max_revision",\
438 .driver = "virtio-balloon-ccw",\
439 .property = "max_revision",\
442 .driver = "virtio-serial-ccw",\
443 .property = "max_revision",\
446 .driver = "virtio-9p-ccw",\
447 .property = "max_revision",\
450 .driver = "virtio-rng-ccw",\
451 .property = "max_revision",\
454 .driver = "virtio-net-ccw",\
455 .property = "max_revision",\
458 .driver = "virtio-scsi-ccw",\
459 .property = "max_revision",\
462 .driver = "vhost-scsi-ccw",\
463 .property = "max_revision",\
467 static void ccw_machine_2_10_instance_options(MachineState
*machine
)
471 static void ccw_machine_2_10_class_options(MachineClass
*mc
)
474 DEFINE_CCW_MACHINE(2_10
, "2.10", true);
476 static void ccw_machine_2_9_instance_options(MachineState
*machine
)
478 ccw_machine_2_10_instance_options(machine
);
481 static void ccw_machine_2_9_class_options(MachineClass
*mc
)
483 ccw_machine_2_10_class_options(mc
);
484 SET_MACHINE_COMPAT(mc
, CCW_COMPAT_2_9
);
486 DEFINE_CCW_MACHINE(2_9
, "2.9", false);
488 static void ccw_machine_2_8_instance_options(MachineState
*machine
)
490 ccw_machine_2_9_instance_options(machine
);
493 static void ccw_machine_2_8_class_options(MachineClass
*mc
)
495 ccw_machine_2_9_class_options(mc
);
496 SET_MACHINE_COMPAT(mc
, CCW_COMPAT_2_8
);
498 DEFINE_CCW_MACHINE(2_8
, "2.8", false);
500 static void ccw_machine_2_7_instance_options(MachineState
*machine
)
502 ccw_machine_2_8_instance_options(machine
);
505 static void ccw_machine_2_7_class_options(MachineClass
*mc
)
507 S390CcwMachineClass
*s390mc
= S390_MACHINE_CLASS(mc
);
509 s390mc
->cpu_model_allowed
= false;
510 ccw_machine_2_8_class_options(mc
);
511 SET_MACHINE_COMPAT(mc
, CCW_COMPAT_2_7
);
513 DEFINE_CCW_MACHINE(2_7
, "2.7", false);
515 static void ccw_machine_2_6_instance_options(MachineState
*machine
)
517 ccw_machine_2_7_instance_options(machine
);
520 static void ccw_machine_2_6_class_options(MachineClass
*mc
)
522 S390CcwMachineClass
*s390mc
= S390_MACHINE_CLASS(mc
);
524 s390mc
->ri_allowed
= false;
525 ccw_machine_2_7_class_options(mc
);
526 SET_MACHINE_COMPAT(mc
, CCW_COMPAT_2_6
);
528 DEFINE_CCW_MACHINE(2_6
, "2.6", false);
530 static void ccw_machine_2_5_instance_options(MachineState
*machine
)
532 ccw_machine_2_6_instance_options(machine
);
535 static void ccw_machine_2_5_class_options(MachineClass
*mc
)
537 ccw_machine_2_6_class_options(mc
);
538 SET_MACHINE_COMPAT(mc
, CCW_COMPAT_2_5
);
540 DEFINE_CCW_MACHINE(2_5
, "2.5", false);
542 static void ccw_machine_2_4_instance_options(MachineState
*machine
)
544 ccw_machine_2_5_instance_options(machine
);
547 static void ccw_machine_2_4_class_options(MachineClass
*mc
)
549 ccw_machine_2_5_class_options(mc
);
550 SET_MACHINE_COMPAT(mc
, CCW_COMPAT_2_4
);
552 DEFINE_CCW_MACHINE(2_4
, "2.4", false);
554 static void ccw_machine_register_types(void)
556 type_register_static(&ccw_machine_info
);
559 type_init(ccw_machine_register_types
)