Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 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 "hw/boards.h" |
| 13 | #include "exec/address-spaces.h" |
| 14 | #include "s390-virtio.h" |
Paolo Bonzini | 83c9f4c | 2013-02-04 15:40:22 +0100 | [diff] [blame] | 15 | #include "hw/s390x/sclp.h" |
Jens Freimann | 3a553fc | 2013-07-16 09:04:04 +0200 | [diff] [blame] | 16 | #include "hw/s390x/s390_flic.h" |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 17 | #include "ioinst.h" |
| 18 | #include "css.h" |
| 19 | #include "virtio-ccw.h" |
Matthew Rosato | b6fe012 | 2014-08-28 11:25:33 -0400 | [diff] [blame] | 20 | #include "qemu/config-file.h" |
Frank Blaschka | 8cba80c | 2015-01-09 09:04:38 +0100 | [diff] [blame] | 21 | #include "s390-pci-bus.h" |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 22 | |
Alexey Kardashevskiy | d07aa7c | 2014-08-20 22:16:34 +1000 | [diff] [blame] | 23 | #define TYPE_S390_CCW_MACHINE "s390-ccw-machine" |
| 24 | |
Tony Krowiak | 2eb1cd0 | 2015-03-12 13:53:51 +0100 | [diff] [blame] | 25 | #define S390_CCW_MACHINE(obj) \ |
| 26 | OBJECT_CHECK(S390CcwMachineState, (obj), TYPE_S390_CCW_MACHINE) |
| 27 | |
| 28 | typedef 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 Borntraeger | 4e872a3 | 2013-07-25 16:37:37 +0200 | [diff] [blame] | 37 | void io_subsystem_reset(void) |
| 38 | { |
Jens Freimann | 3a553fc | 2013-07-16 09:04:04 +0200 | [diff] [blame] | 39 | DeviceState *css, *sclp, *flic; |
Christian Borntraeger | 4e872a3 | 2013-07-25 16:37:37 +0200 | [diff] [blame] | 40 | |
| 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 Freimann | 3a553fc | 2013-07-16 09:04:04 +0200 | [diff] [blame] | 50 | flic = DEVICE(object_resolve_path_type("", "s390-flic", NULL)); |
| 51 | if (flic) { |
| 52 | qdev_reset_all(flic); |
| 53 | } |
Christian Borntraeger | 4e872a3 | 2013-07-25 16:37:37 +0200 | [diff] [blame] | 54 | } |
| 55 | |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 56 | static 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 Wang | 8dfbaa6 | 2015-05-29 14:15:27 +0800 | [diff] [blame] | 70 | if (queue >= VIRTIO_CCW_QUEUE_MAX) { |
Cornelia Huck | b57ed9b | 2013-03-26 17:32:44 +0100 | [diff] [blame] | 71 | return -EINVAL; |
| 72 | } |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 73 | virtio_queue_notify(virtio_ccw_get_vdev(sch), queue); |
| 74 | return 0; |
| 75 | |
| 76 | } |
| 77 | |
| 78 | static 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 | |
| 89 | static 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 Apfelbaum | 3ef9622 | 2014-05-07 17:42:57 +0300 | [diff] [blame] | 98 | static void ccw_init(MachineState *machine) |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 99 | { |
Marcel Apfelbaum | 3ef9622 | 2014-05-07 17:42:57 +0300 | [diff] [blame] | 100 | ram_addr_t my_ram_size = machine->ram_size; |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 101 | MemoryRegion *sysmem = get_system_memory(); |
| 102 | MemoryRegion *ram = g_new(MemoryRegion, 1); |
Matthew Rosato | b6fe012 | 2014-08-28 11:25:33 -0400 | [diff] [blame] | 103 | sclpMemoryHotplugDev *mhd = init_sclp_memory_hotplug_dev(); |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 104 | uint8_t *storage_keys; |
| 105 | int ret; |
| 106 | VirtualCssBus *css_bus; |
Frank Blaschka | 8cba80c | 2015-01-09 09:04:38 +0100 | [diff] [blame] | 107 | DeviceState *dev; |
Matthew Rosato | b6fe012 | 2014-08-28 11:25:33 -0400 | [diff] [blame] | 108 | 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 Dingel | a310b28 | 2015-03-05 16:56:21 +0100 | [diff] [blame] | 112 | uint64_t kvm_limit; |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 113 | |
Matthew Rosato | b6fe012 | 2014-08-28 11:25:33 -0400 | [diff] [blame] | 114 | /* 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 Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 121 | } |
Matthew Rosato | b6fe012 | 2014-08-28 11:25:33 -0400 | [diff] [blame] | 122 | 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 Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 134 | |
Peter Maydell | e03ba13 | 2013-04-09 12:48:19 +0100 | [diff] [blame] | 135 | /* let's propagate the changed ram size into the global variable. */ |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 136 | ram_size = my_ram_size; |
Dominik Dingel | a310b28 | 2015-03-05 16:56:21 +0100 | [diff] [blame] | 137 | 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 Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 146 | |
| 147 | /* get a BUS */ |
| 148 | css_bus = virtual_css_bus_init(); |
| 149 | s390_sclp_init(); |
Marcel Apfelbaum | 3ef9622 | 2014-05-07 17:42:57 +0300 | [diff] [blame] | 150 | s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline, |
Fan Zhang | f0180f9 | 2015-02-12 18:02:13 +0100 | [diff] [blame] | 151 | machine->initrd_filename, "s390-ccw.img", true); |
Jens Freimann | 3a553fc | 2013-07-16 09:04:04 +0200 | [diff] [blame] | 152 | s390_flic_init(); |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 153 | |
Frank Blaschka | 8cba80c | 2015-01-09 09:04:38 +0100 | [diff] [blame] | 154 | 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 Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 159 | /* register hypercalls */ |
| 160 | virtio_ccw_register_hcalls(); |
| 161 | |
Matthew Rosato | b6fe012 | 2014-08-28 11:25:33 -0400 | [diff] [blame] | 162 | /* allocate RAM for core */ |
Hu Tao | 4994653 | 2014-09-09 13:27:55 +0800 | [diff] [blame] | 163 | memory_region_init_ram(ram, NULL, "s390.ram", my_ram_size, &error_abort); |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 164 | vmstate_register_ram_global(ram); |
| 165 | memory_region_add_subregion(sysmem, 0, ram); |
| 166 | |
Matthew Rosato | b6fe012 | 2014-08-28 11:25:33 -0400 | [diff] [blame] | 167 | /* 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 Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 178 | /* allocate storage keys */ |
| 179 | storage_keys = g_malloc0(my_ram_size / TARGET_PAGE_SIZE); |
| 180 | |
| 181 | /* init CPUs */ |
Marcel Apfelbaum | 3ef9622 | 2014-05-07 17:42:57 +0300 | [diff] [blame] | 182 | s390_init_cpus(machine->cpu_model, storage_keys); |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 183 | |
| 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. Herne | 3f9e59b | 2015-03-09 15:56:08 +0100 | [diff] [blame] | 196 | |
| 197 | /* Register savevm handler for guest TOD clock */ |
| 198 | register_savevm(NULL, "todclock", 0, 1, |
| 199 | gtod_save, gtod_load, kvm_state); |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 200 | } |
| 201 | |
Alexey Kardashevskiy | d07aa7c | 2014-08-20 22:16:34 +1000 | [diff] [blame] | 202 | static void ccw_machine_class_init(ObjectClass *oc, void *data) |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 203 | { |
Alexey Kardashevskiy | d07aa7c | 2014-08-20 22:16:34 +1000 | [diff] [blame] | 204 | MachineClass *mc = MACHINE_CLASS(oc); |
Alexey Kardashevskiy | 3dd7852 | 2014-08-20 22:16:35 +1000 | [diff] [blame] | 205 | NMIClass *nc = NMI_CLASS(oc); |
Alexey Kardashevskiy | d07aa7c | 2014-08-20 22:16:34 +1000 | [diff] [blame] | 206 | |
| 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 Huck | fb85b34 | 2014-12-03 15:38:28 +0100 | [diff] [blame] | 217 | mc->use_sclp = 1; |
Alexey Kardashevskiy | d07aa7c | 2014-08-20 22:16:34 +1000 | [diff] [blame] | 218 | mc->max_cpus = 255; |
Alexey Kardashevskiy | 3dd7852 | 2014-08-20 22:16:35 +1000 | [diff] [blame] | 219 | nc->nmi_monitor_handler = s390_nmi; |
Cornelia Huck | a5c9580 | 2013-01-24 06:08:56 +0000 | [diff] [blame] | 220 | } |
| 221 | |
Tony Krowiak | 2eb1cd0 | 2015-03-12 13:53:51 +0100 | [diff] [blame] | 222 | static 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 | |
| 229 | static 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 | |
| 237 | static 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 | |
| 244 | static 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 | |
| 252 | static 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 Kardashevskiy | d07aa7c | 2014-08-20 22:16:34 +1000 | [diff] [blame] | 271 | static const TypeInfo ccw_machine_info = { |
| 272 | .name = TYPE_S390_CCW_MACHINE, |
| 273 | .parent = TYPE_MACHINE, |
Tony Krowiak | 2eb1cd0 | 2015-03-12 13:53:51 +0100 | [diff] [blame] | 274 | .instance_size = sizeof(S390CcwMachineState), |
| 275 | .instance_init = s390_machine_initfn, |
Alexey Kardashevskiy | d07aa7c | 2014-08-20 22:16:34 +1000 | [diff] [blame] | 276 | .class_init = ccw_machine_class_init, |
Alexey Kardashevskiy | 3dd7852 | 2014-08-20 22:16:35 +1000 | [diff] [blame] | 277 | .interfaces = (InterfaceInfo[]) { |
| 278 | { TYPE_NMI }, |
| 279 | { } |
| 280 | }, |
Alexey Kardashevskiy | d07aa7c | 2014-08-20 22:16:34 +1000 | [diff] [blame] | 281 | }; |
| 282 | |
| 283 | static void ccw_machine_register_types(void) |
| 284 | { |
| 285 | type_register_static(&ccw_machine_info); |
| 286 | } |
| 287 | |
| 288 | type_init(ccw_machine_register_types) |