hw/s390x/s390-virtio-ccw.c

   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"
  15 #include "hw/s390x/sclp.h"
  16 #include "hw/s390x/s390_flic.h"
  17 #include "ioinst.h"
  18 #include "css.h"
  19 #include "virtio-ccw.h"
  20 #include "qemu/config-file.h"
  21 #include "s390-pci-bus.h"
  22 #include "hw/s390x/storage-keys.h"
  23 #include "hw/compat.h"
  24
  25 #define TYPE_S390_CCW_MACHINE               "s390-ccw-machine"
  26
  27 #define S390_CCW_MACHINE(obj) \
  28     OBJECT_CHECK(S390CcwMachineState, (obj), TYPE_S390_CCW_MACHINE)
  29
  30 typedef struct S390CcwMachineState {
  31     /*< private >*/
  32     MachineState parent_obj;
  33
  34     /*< public >*/
  35     bool aes_key_wrap;
  36     bool dea_key_wrap;
  37 } S390CcwMachineState;
  38
  39 static const char *const reset_dev_types[] = {
  40     "virtual-css-bridge",
  41     "s390-sclp-event-facility",
  42     "s390-flic",
  43     "diag288",
  44 };
  45
  46 void subsystem_reset(void)
  47 {
  48     DeviceState *dev;
  49     int i;
  50
  51     for (i = 0; i < ARRAY_SIZE(reset_dev_types); i++) {
  52         dev = DEVICE(object_resolve_path_type("", reset_dev_types[i], NULL));
  53         if (dev) {
  54             qdev_reset_all(dev);
  55         }
  56     }
  57 }
  58
  59 static int virtio_ccw_hcall_notify(const uint64_t *args)
  60 {
  61     uint64_t subch_id = args[0];
  62     uint64_t queue = args[1];
  63     SubchDev *sch;
  64     int cssid, ssid, schid, m;
  65
  66     if (ioinst_disassemble_sch_ident(subch_id, &m, &cssid, &ssid, &schid)) {
  67         return -EINVAL;
  68     }
  69     sch = css_find_subch(m, cssid, ssid, schid);
  70     if (!sch || !css_subch_visible(sch)) {
  71         return -EINVAL;
  72     }
  73     if (queue >= VIRTIO_CCW_QUEUE_MAX) {
  74         return -EINVAL;
  75     }
  76     virtio_queue_notify(virtio_ccw_get_vdev(sch), queue);
  77     return 0;
  78
  79 }
  80
  81 static int virtio_ccw_hcall_early_printk(const uint64_t *args)
  82 {
  83     uint64_t mem = args[0];
  84
  85     if (mem < ram_size) {
  86         /* Early printk */
  87         return 0;
  88     }
  89     return -EINVAL;
  90 }
  91
  92 static void virtio_ccw_register_hcalls(void)
  93 {
  94     s390_register_virtio_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY,
  95                                    virtio_ccw_hcall_notify);
  96     /* Tolerate early printk. */
  97     s390_register_virtio_hypercall(KVM_S390_VIRTIO_NOTIFY,
  98                                    virtio_ccw_hcall_early_printk);
  99 }
 100
 101 void s390_memory_init(ram_addr_t mem_size)
 102 {
 103     MemoryRegion *sysmem = get_system_memory();
 104     MemoryRegion *ram = g_new(MemoryRegion, 1);
 105
 106     /* allocate RAM for core */
 107     memory_region_init_ram(ram, NULL, "s390.ram", mem_size, &error_fatal);
 108     vmstate_register_ram_global(ram);
 109     memory_region_add_subregion(sysmem, 0, ram);
 110
 111     /* Initialize storage key device */
 112     s390_skeys_init();
 113 }
 114
 115 static void ccw_init(MachineState *machine)
 116 {
 117     int ret;
 118     VirtualCssBus *css_bus;
 119     DeviceState *dev;
 120
 121     s390_sclp_init();
 122     s390_memory_init(machine->ram_size);
 123
 124     /* get a BUS */
 125     css_bus = virtual_css_bus_init();
 126     s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline,
 127                       machine->initrd_filename, "s390-ccw.img", true);
 128     s390_flic_init();
 129
 130     dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE);
 131     object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE,
 132                               OBJECT(dev), NULL);
 133     qdev_init_nofail(dev);
 134
 135     /* register hypercalls */
 136     virtio_ccw_register_hcalls();
 137
 138     /* init CPUs */
 139     s390_init_cpus(machine->cpu_model);
 140
 141     if (kvm_enabled()) {
 142         kvm_s390_enable_css_support(s390_cpu_addr2state(0));
 143     }
 144     /*
 145      * Create virtual css and set it as default so that non mcss-e
 146      * enabled guests only see virtio devices.
 147      */
 148     ret = css_create_css_image(VIRTUAL_CSSID, true);
 149     assert(ret == 0);
 150
 151     /* Create VirtIO network adapters */
 152     s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw");
 153
 154     /* Register savevm handler for guest TOD clock */
 155     register_savevm(NULL, "todclock", 0, 1,
 156                     gtod_save, gtod_load, kvm_state);
 157 }
 158
 159 static void ccw_machine_class_init(ObjectClass *oc, void *data)
 160 {
 161     MachineClass *mc = MACHINE_CLASS(oc);
 162     NMIClass *nc = NMI_CLASS(oc);
 163
 164     mc->init = ccw_init;
 165     mc->reset = s390_machine_reset;
 166     mc->block_default_type = IF_VIRTIO;
 167     mc->no_cdrom = 1;
 168     mc->no_floppy = 1;
 169     mc->no_serial = 1;
 170     mc->no_parallel = 1;
 171     mc->no_sdcard = 1;
 172     mc->use_sclp = 1;
 173     mc->max_cpus = 255;
 174     nc->nmi_monitor_handler = s390_nmi;
 175 }
 176
 177 static inline bool machine_get_aes_key_wrap(Object *obj, Error **errp)
 178 {
 179     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 180
 181     return ms->aes_key_wrap;
 182 }
 183
 184 static inline void machine_set_aes_key_wrap(Object *obj, bool value,
 185                                             Error **errp)
 186 {
 187     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 188
 189     ms->aes_key_wrap = value;
 190 }
 191
 192 static inline bool machine_get_dea_key_wrap(Object *obj, Error **errp)
 193 {
 194     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 195
 196     return ms->dea_key_wrap;
 197 }
 198
 199 static inline void machine_set_dea_key_wrap(Object *obj, bool value,
 200                                             Error **errp)
 201 {
 202     S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
 203
 204     ms->dea_key_wrap = value;
 205 }
 206
 207 static inline void s390_machine_initfn(Object *obj)
 208 {
 209     object_property_add_bool(obj, "aes-key-wrap",
 210                              machine_get_aes_key_wrap,
 211                              machine_set_aes_key_wrap, NULL);
 212     object_property_set_description(obj, "aes-key-wrap",
 213             "enable/disable AES key wrapping using the CPACF wrapping key",
 214             NULL);
 215     object_property_set_bool(obj, true, "aes-key-wrap", NULL);
 216
 217     object_property_add_bool(obj, "dea-key-wrap",
 218                              machine_get_dea_key_wrap,
 219                              machine_set_dea_key_wrap, NULL);
 220     object_property_set_description(obj, "dea-key-wrap",
 221             "enable/disable DEA key wrapping using the CPACF wrapping key",
 222             NULL);
 223     object_property_set_bool(obj, true, "dea-key-wrap", NULL);
 224 }
 225
 226 static const TypeInfo ccw_machine_info = {
 227     .name          = TYPE_S390_CCW_MACHINE,
 228     .parent        = TYPE_MACHINE,
 229     .abstract      = true,
 230     .instance_size = sizeof(S390CcwMachineState),
 231     .instance_init = s390_machine_initfn,
 232     .class_init    = ccw_machine_class_init,
 233     .interfaces = (InterfaceInfo[]) {
 234         { TYPE_NMI },
 235         { }
 236     },
 237 };
 238
 239 #define CCW_COMPAT_2_4 \
 240         HW_COMPAT_2_4 \
 241         {\
 242             .driver   = TYPE_S390_SKEYS,\
 243             .property = "migration-enabled",\
 244             .value    = "off",\
 245         },{\
 246             .driver   = "virtio-blk-ccw",\
 247             .property = "max_revision",\
 248             .value    = "0",\
 249         },{\
 250             .driver   = "virtio-balloon-ccw",\
 251             .property = "max_revision",\
 252             .value    = "0",\
 253         },{\
 254             .driver   = "virtio-serial-ccw",\
 255             .property = "max_revision",\
 256             .value    = "0",\
 257         },{\
 258             .driver   = "virtio-9p-ccw",\
 259             .property = "max_revision",\
 260             .value    = "0",\
 261         },{\
 262             .driver   = "virtio-rng-ccw",\
 263             .property = "max_revision",\
 264             .value    = "0",\
 265         },{\
 266             .driver   = "virtio-net-ccw",\
 267             .property = "max_revision",\
 268             .value    = "0",\
 269         },{\
 270             .driver   = "virtio-scsi-ccw",\
 271             .property = "max_revision",\
 272             .value    = "0",\
 273         },{\
 274             .driver   = "vhost-scsi-ccw",\
 275             .property = "max_revision",\
 276             .value    = "0",\
 277         },
 278
 279 static void ccw_machine_2_4_class_init(ObjectClass *oc, void *data)
 280 {
 281     MachineClass *mc = MACHINE_CLASS(oc);
 282     static GlobalProperty compat_props[] = {
 283         CCW_COMPAT_2_4
 284         { /* end of list */ }
 285     };
 286
 287     mc->desc = "VirtIO-ccw based S390 machine v2.4";
 288     mc->compat_props = compat_props;
 289 }
 290
 291 static const TypeInfo ccw_machine_2_4_info = {
 292     .name          = MACHINE_TYPE_NAME("s390-ccw-virtio-2.4"),
 293     .parent        = TYPE_S390_CCW_MACHINE,
 294     .class_init    = ccw_machine_2_4_class_init,
 295 };
 296
 297 static void ccw_machine_2_5_class_init(ObjectClass *oc, void *data)
 298 {
 299     MachineClass *mc = MACHINE_CLASS(oc);
 300
 301     mc->alias = "s390-ccw-virtio";
 302     mc->desc = "VirtIO-ccw based S390 machine v2.5";
 303     mc->is_default = 1;
 304 }
 305
 306 static const TypeInfo ccw_machine_2_5_info = {
 307     .name          = MACHINE_TYPE_NAME("s390-ccw-virtio-2.5"),
 308     .parent        = TYPE_S390_CCW_MACHINE,
 309     .class_init    = ccw_machine_2_5_class_init,
 310 };
 311
 312 static void ccw_machine_register_types(void)
 313 {
 314     type_register_static(&ccw_machine_info);
 315     type_register_static(&ccw_machine_2_4_info);
 316     type_register_static(&ccw_machine_2_5_info);
 317 }
 318
 319 type_init(ccw_machine_register_types)