blob: 8a565f657a10ce43ec52eb2d213310f2edd26ab0 [file] [log] [blame]
Cornelia Hucka5c95802013-01-24 06:08:56 +00001/*
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 "hw/boards.h"
13#include "exec/address-spaces.h"
14#include "s390-virtio.h"
Paolo Bonzini83c9f4c2013-02-04 15:40:22 +010015#include "hw/s390x/sclp.h"
Jens Freimann3a553fc2013-07-16 09:04:04 +020016#include "hw/s390x/s390_flic.h"
Cornelia Hucka5c95802013-01-24 06:08:56 +000017#include "ioinst.h"
18#include "css.h"
19#include "virtio-ccw.h"
Matthew Rosatob6fe0122014-08-28 11:25:33 -040020#include "qemu/config-file.h"
Frank Blaschka8cba80c2015-01-09 09:04:38 +010021#include "s390-pci-bus.h"
Cornelia Hucka5c95802013-01-24 06:08:56 +000022
Alexey Kardashevskiyd07aa7c2014-08-20 22:16:34 +100023#define TYPE_S390_CCW_MACHINE "s390-ccw-machine"
24
Tony Krowiak2eb1cd02015-03-12 13:53:51 +010025#define S390_CCW_MACHINE(obj) \
26 OBJECT_CHECK(S390CcwMachineState, (obj), TYPE_S390_CCW_MACHINE)
27
28typedef struct S390CcwMachineState {
29 /*< private >*/
30 MachineState parent_obj;
31
32 /*< public >*/
33 bool aes_key_wrap;
34 bool dea_key_wrap;
35} S390CcwMachineState;
36
Christian Borntraeger4e872a32013-07-25 16:37:37 +020037void io_subsystem_reset(void)
38{
Jens Freimann3a553fc2013-07-16 09:04:04 +020039 DeviceState *css, *sclp, *flic;
Christian Borntraeger4e872a32013-07-25 16:37:37 +020040
41 css = DEVICE(object_resolve_path_type("", "virtual-css-bridge", NULL));
42 if (css) {
43 qdev_reset_all(css);
44 }
45 sclp = DEVICE(object_resolve_path_type("",
46 "s390-sclp-event-facility", NULL));
47 if (sclp) {
48 qdev_reset_all(sclp);
49 }
Jens Freimann3a553fc2013-07-16 09:04:04 +020050 flic = DEVICE(object_resolve_path_type("", "s390-flic", NULL));
51 if (flic) {
52 qdev_reset_all(flic);
53 }
Christian Borntraeger4e872a32013-07-25 16:37:37 +020054}
55
Cornelia Hucka5c95802013-01-24 06:08:56 +000056static int virtio_ccw_hcall_notify(const uint64_t *args)
57{
58 uint64_t subch_id = args[0];
59 uint64_t queue = args[1];
60 SubchDev *sch;
61 int cssid, ssid, schid, m;
62
63 if (ioinst_disassemble_sch_ident(subch_id, &m, &cssid, &ssid, &schid)) {
64 return -EINVAL;
65 }
66 sch = css_find_subch(m, cssid, ssid, schid);
67 if (!sch || !css_subch_visible(sch)) {
68 return -EINVAL;
69 }
Jason Wang8dfbaa62015-05-29 14:15:27 +080070 if (queue >= VIRTIO_CCW_QUEUE_MAX) {
Cornelia Huckb57ed9b2013-03-26 17:32:44 +010071 return -EINVAL;
72 }
Cornelia Hucka5c95802013-01-24 06:08:56 +000073 virtio_queue_notify(virtio_ccw_get_vdev(sch), queue);
74 return 0;
75
76}
77
78static int virtio_ccw_hcall_early_printk(const uint64_t *args)
79{
80 uint64_t mem = args[0];
81
82 if (mem < ram_size) {
83 /* Early printk */
84 return 0;
85 }
86 return -EINVAL;
87}
88
89static void virtio_ccw_register_hcalls(void)
90{
91 s390_register_virtio_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY,
92 virtio_ccw_hcall_notify);
93 /* Tolerate early printk. */
94 s390_register_virtio_hypercall(KVM_S390_VIRTIO_NOTIFY,
95 virtio_ccw_hcall_early_printk);
96}
97
Marcel Apfelbaum3ef96222014-05-07 17:42:57 +030098static void ccw_init(MachineState *machine)
Cornelia Hucka5c95802013-01-24 06:08:56 +000099{
Marcel Apfelbaum3ef96222014-05-07 17:42:57 +0300100 ram_addr_t my_ram_size = machine->ram_size;
Cornelia Hucka5c95802013-01-24 06:08:56 +0000101 MemoryRegion *sysmem = get_system_memory();
102 MemoryRegion *ram = g_new(MemoryRegion, 1);
Matthew Rosatob6fe0122014-08-28 11:25:33 -0400103 sclpMemoryHotplugDev *mhd = init_sclp_memory_hotplug_dev();
Cornelia Hucka5c95802013-01-24 06:08:56 +0000104 uint8_t *storage_keys;
105 int ret;
106 VirtualCssBus *css_bus;
Frank Blaschka8cba80c2015-01-09 09:04:38 +0100107 DeviceState *dev;
Matthew Rosatob6fe0122014-08-28 11:25:33 -0400108 QemuOpts *opts = qemu_opts_find(qemu_find_opts("memory"), NULL);
109 ram_addr_t pad_size = 0;
110 ram_addr_t maxmem = qemu_opt_get_size(opts, "maxmem", my_ram_size);
111 ram_addr_t standby_mem_size = maxmem - my_ram_size;
Dominik Dingela310b282015-03-05 16:56:21 +0100112 uint64_t kvm_limit;
Cornelia Hucka5c95802013-01-24 06:08:56 +0000113
Matthew Rosatob6fe0122014-08-28 11:25:33 -0400114 /* The storage increment size is a multiple of 1M and is a power of 2.
115 * The number of storage increments must be MAX_STORAGE_INCREMENTS or fewer.
116 * The variable 'mhd->increment_size' is an exponent of 2 that can be
117 * used to calculate the size (in bytes) of an increment. */
118 mhd->increment_size = 20;
119 while ((my_ram_size >> mhd->increment_size) > MAX_STORAGE_INCREMENTS) {
120 mhd->increment_size++;
Cornelia Hucka5c95802013-01-24 06:08:56 +0000121 }
Matthew Rosatob6fe0122014-08-28 11:25:33 -0400122 while ((standby_mem_size >> mhd->increment_size) > MAX_STORAGE_INCREMENTS) {
123 mhd->increment_size++;
124 }
125
126 /* The core and standby memory areas need to be aligned with
127 * the increment size. In effect, this can cause the
128 * user-specified memory size to be rounded down to align
129 * with the nearest increment boundary. */
130 standby_mem_size = standby_mem_size >> mhd->increment_size
131 << mhd->increment_size;
132 my_ram_size = my_ram_size >> mhd->increment_size
133 << mhd->increment_size;
Cornelia Hucka5c95802013-01-24 06:08:56 +0000134
Peter Maydelle03ba132013-04-09 12:48:19 +0100135 /* let's propagate the changed ram size into the global variable. */
Cornelia Hucka5c95802013-01-24 06:08:56 +0000136 ram_size = my_ram_size;
Dominik Dingela310b282015-03-05 16:56:21 +0100137 machine->maxram_size = my_ram_size + standby_mem_size;
138
139 ret = s390_set_memory_limit(machine->maxram_size, &kvm_limit);
140 if (ret == -E2BIG) {
141 hw_error("qemu: host supports a maximum of %" PRIu64 " GB",
142 kvm_limit >> 30);
143 } else if (ret) {
144 hw_error("qemu: setting the guest size failed");
145 }
Cornelia Hucka5c95802013-01-24 06:08:56 +0000146
147 /* get a BUS */
148 css_bus = virtual_css_bus_init();
149 s390_sclp_init();
Marcel Apfelbaum3ef96222014-05-07 17:42:57 +0300150 s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline,
Fan Zhangf0180f92015-02-12 18:02:13 +0100151 machine->initrd_filename, "s390-ccw.img", true);
Jens Freimann3a553fc2013-07-16 09:04:04 +0200152 s390_flic_init();
Cornelia Hucka5c95802013-01-24 06:08:56 +0000153
Frank Blaschka8cba80c2015-01-09 09:04:38 +0100154 dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE);
155 object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE,
156 OBJECT(dev), NULL);
157 qdev_init_nofail(dev);
158
Cornelia Hucka5c95802013-01-24 06:08:56 +0000159 /* register hypercalls */
160 virtio_ccw_register_hcalls();
161
Matthew Rosatob6fe0122014-08-28 11:25:33 -0400162 /* allocate RAM for core */
Hu Tao49946532014-09-09 13:27:55 +0800163 memory_region_init_ram(ram, NULL, "s390.ram", my_ram_size, &error_abort);
Cornelia Hucka5c95802013-01-24 06:08:56 +0000164 vmstate_register_ram_global(ram);
165 memory_region_add_subregion(sysmem, 0, ram);
166
Matthew Rosatob6fe0122014-08-28 11:25:33 -0400167 /* If the size of ram is not on a MEM_SECTION_SIZE boundary,
168 calculate the pad size necessary to force this boundary. */
169 if (standby_mem_size) {
170 if (my_ram_size % MEM_SECTION_SIZE) {
171 pad_size = MEM_SECTION_SIZE - my_ram_size % MEM_SECTION_SIZE;
172 }
173 my_ram_size += standby_mem_size + pad_size;
174 mhd->pad_size = pad_size;
175 mhd->standby_mem_size = standby_mem_size;
176 }
177
Cornelia Hucka5c95802013-01-24 06:08:56 +0000178 /* allocate storage keys */
179 storage_keys = g_malloc0(my_ram_size / TARGET_PAGE_SIZE);
180
181 /* init CPUs */
Marcel Apfelbaum3ef96222014-05-07 17:42:57 +0300182 s390_init_cpus(machine->cpu_model, storage_keys);
Cornelia Hucka5c95802013-01-24 06:08:56 +0000183
184 if (kvm_enabled()) {
185 kvm_s390_enable_css_support(s390_cpu_addr2state(0));
186 }
187 /*
188 * Create virtual css and set it as default so that non mcss-e
189 * enabled guests only see virtio devices.
190 */
191 ret = css_create_css_image(VIRTUAL_CSSID, true);
192 assert(ret == 0);
193
194 /* Create VirtIO network adapters */
195 s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw");
Jason J. Herne3f9e59b2015-03-09 15:56:08 +0100196
197 /* Register savevm handler for guest TOD clock */
198 register_savevm(NULL, "todclock", 0, 1,
199 gtod_save, gtod_load, kvm_state);
Cornelia Hucka5c95802013-01-24 06:08:56 +0000200}
201
Alexey Kardashevskiyd07aa7c2014-08-20 22:16:34 +1000202static void ccw_machine_class_init(ObjectClass *oc, void *data)
Cornelia Hucka5c95802013-01-24 06:08:56 +0000203{
Alexey Kardashevskiyd07aa7c2014-08-20 22:16:34 +1000204 MachineClass *mc = MACHINE_CLASS(oc);
Alexey Kardashevskiy3dd78522014-08-20 22:16:35 +1000205 NMIClass *nc = NMI_CLASS(oc);
Alexey Kardashevskiyd07aa7c2014-08-20 22:16:34 +1000206
207 mc->name = "s390-ccw-virtio";
208 mc->alias = "s390-ccw";
209 mc->desc = "VirtIO-ccw based S390 machine";
210 mc->init = ccw_init;
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;
Cornelia Huckfb85b342014-12-03 15:38:28 +0100217 mc->use_sclp = 1;
Alexey Kardashevskiyd07aa7c2014-08-20 22:16:34 +1000218 mc->max_cpus = 255;
Alexey Kardashevskiy3dd78522014-08-20 22:16:35 +1000219 nc->nmi_monitor_handler = s390_nmi;
Cornelia Hucka5c95802013-01-24 06:08:56 +0000220}
221
Tony Krowiak2eb1cd02015-03-12 13:53:51 +0100222static inline bool machine_get_aes_key_wrap(Object *obj, Error **errp)
223{
224 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
225
226 return ms->aes_key_wrap;
227}
228
229static inline void machine_set_aes_key_wrap(Object *obj, bool value,
230 Error **errp)
231{
232 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
233
234 ms->aes_key_wrap = value;
235}
236
237static inline bool machine_get_dea_key_wrap(Object *obj, Error **errp)
238{
239 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
240
241 return ms->dea_key_wrap;
242}
243
244static inline void machine_set_dea_key_wrap(Object *obj, bool value,
245 Error **errp)
246{
247 S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
248
249 ms->dea_key_wrap = value;
250}
251
252static inline void s390_machine_initfn(Object *obj)
253{
254 object_property_add_bool(obj, "aes-key-wrap",
255 machine_get_aes_key_wrap,
256 machine_set_aes_key_wrap, NULL);
257 object_property_set_description(obj, "aes-key-wrap",
258 "enable/disable AES key wrapping using the CPACF wrapping key",
259 NULL);
260 object_property_set_bool(obj, true, "aes-key-wrap", NULL);
261
262 object_property_add_bool(obj, "dea-key-wrap",
263 machine_get_dea_key_wrap,
264 machine_set_dea_key_wrap, NULL);
265 object_property_set_description(obj, "dea-key-wrap",
266 "enable/disable DEA key wrapping using the CPACF wrapping key",
267 NULL);
268 object_property_set_bool(obj, true, "dea-key-wrap", NULL);
269}
270
Alexey Kardashevskiyd07aa7c2014-08-20 22:16:34 +1000271static const TypeInfo ccw_machine_info = {
272 .name = TYPE_S390_CCW_MACHINE,
273 .parent = TYPE_MACHINE,
Tony Krowiak2eb1cd02015-03-12 13:53:51 +0100274 .instance_size = sizeof(S390CcwMachineState),
275 .instance_init = s390_machine_initfn,
Alexey Kardashevskiyd07aa7c2014-08-20 22:16:34 +1000276 .class_init = ccw_machine_class_init,
Alexey Kardashevskiy3dd78522014-08-20 22:16:35 +1000277 .interfaces = (InterfaceInfo[]) {
278 { TYPE_NMI },
279 { }
280 },
Alexey Kardashevskiyd07aa7c2014-08-20 22:16:34 +1000281};
282
283static void ccw_machine_register_types(void)
284{
285 type_register_static(&ccw_machine_info);
286}
287
288type_init(ccw_machine_register_types)