hw/s390x/sclp.c

   1 /*
   2  * SCLP Support
   3  *
   4  * Copyright IBM, Corp. 2012
   5  *
   6  * Authors:
   7  *  Christian Borntraeger <borntraeger@de.ibm.com>
   8  *  Heinz Graalfs <graalfs@linux.vnet.ibm.com>
   9  *
  10  * This work is licensed under the terms of the GNU GPL, version 2 or (at your
  11  * option) any later version.  See the COPYING file in the top-level directory.
  12  *
  13  */
  14
  15 #include "qemu/osdep.h"
  16 #include "qemu/units.h"
  17 #include "qapi/error.h"
  18 #include "cpu.h"
  19 #include "sysemu/sysemu.h"
  20 #include "hw/boards.h"
  21 #include "hw/s390x/sclp.h"
  22 #include "hw/s390x/event-facility.h"
  23 #include "hw/s390x/s390-pci-bus.h"
  24 #include "hw/s390x/ipl.h"
  25
  26 static inline SCLPDevice *get_sclp_device(void)
  27 {
  28     static SCLPDevice *sclp;
  29
  30     if (!sclp) {
  31         sclp = SCLP(object_resolve_path_type("", TYPE_SCLP, NULL));
  32     }
  33     return sclp;
  34 }
  35
  36 static inline bool sclp_command_code_valid(uint32_t code)
  37 {
  38     switch (code & SCLP_CMD_CODE_MASK) {
  39     case SCLP_CMDW_READ_SCP_INFO:
  40     case SCLP_CMDW_READ_SCP_INFO_FORCED:
  41     case SCLP_CMDW_READ_CPU_INFO:
  42     case SCLP_CMDW_CONFIGURE_IOA:
  43     case SCLP_CMDW_DECONFIGURE_IOA:
  44     case SCLP_CMD_READ_EVENT_DATA:
  45     case SCLP_CMD_WRITE_EVENT_DATA:
  46     case SCLP_CMD_WRITE_EVENT_MASK:
  47         return true;
  48     }
  49     return false;
  50 }
  51
  52 static bool sccb_verify_boundary(uint64_t sccb_addr, uint16_t sccb_len)
  53 {
  54     uint64_t sccb_max_addr = sccb_addr + sccb_len - 1;
  55     uint64_t sccb_boundary = (sccb_addr & PAGE_MASK) + PAGE_SIZE;
  56
  57     if (sccb_max_addr < sccb_boundary) {
  58         return true;
  59     }
  60
  61     return false;
  62 }
  63
  64 static void prepare_cpu_entries(MachineState *ms, CPUEntry *entry, int *count)
  65 {
  66     uint8_t features[SCCB_CPU_FEATURE_LEN] = { 0 };
  67     int i;
  68
  69     s390_get_feat_block(S390_FEAT_TYPE_SCLP_CPU, features);
  70     for (i = 0, *count = 0; i < ms->possible_cpus->len; i++) {
  71         if (!ms->possible_cpus->cpus[i].cpu) {
  72             continue;
  73         }
  74         entry[*count].address = ms->possible_cpus->cpus[i].arch_id;
  75         entry[*count].type = 0;
  76         memcpy(entry[*count].features, features, sizeof(features));
  77         (*count)++;
  78     }
  79 }
  80
  81 #define SCCB_REQ_LEN(s, max_cpus) (sizeof(s) + max_cpus * sizeof(CPUEntry))
  82
  83 /* Provide information about the configuration, CPUs and storage */
  84 static void read_SCP_info(SCLPDevice *sclp, SCCB *sccb)
  85 {
  86     ReadInfo *read_info = (ReadInfo *) sccb;
  87     MachineState *machine = MACHINE(qdev_get_machine());
  88     int cpu_count;
  89     int rnsize, rnmax;
  90     IplParameterBlock *ipib = s390_ipl_get_iplb();
  91     int required_len = SCCB_REQ_LEN(ReadInfo, machine->possible_cpus->len);
  92     int offset_cpu = offsetof(ReadInfo, entries);
  93     CPUEntry *entries_start = (void *)sccb + offset_cpu;
  94
  95     if (be16_to_cpu(sccb->h.length) < required_len) {
  96         sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
  97         return;
  98     }
  99
 100     /* CPU information */
 101     prepare_cpu_entries(machine, entries_start, &cpu_count);
 102     read_info->entries_cpu = cpu_to_be16(cpu_count);
 103     read_info->offset_cpu = cpu_to_be16(offset_cpu);
 104     read_info->highest_cpu = cpu_to_be16(machine->smp.max_cpus - 1);
 105
 106     read_info->ibc_val = cpu_to_be32(s390_get_ibc_val());
 107
 108     /* Configuration Characteristic (Extension) */
 109     s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR,
 110                          read_info->conf_char);
 111     s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR_EXT,
 112                          read_info->conf_char_ext);
 113
 114     read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO |
 115                                         SCLP_HAS_IOA_RECONFIG);
 116
 117     read_info->mha_pow = s390_get_mha_pow();
 118     read_info->hmfai = cpu_to_be32(s390_get_hmfai());
 119
 120     rnsize = 1 << (sclp->increment_size - 20);
 121     if (rnsize <= 128) {
 122         read_info->rnsize = rnsize;
 123     } else {
 124         read_info->rnsize = 0;
 125         read_info->rnsize2 = cpu_to_be32(rnsize);
 126     }
 127
 128     /* we don't support standby memory, maxram_size is never exposed */
 129     rnmax = machine->ram_size >> sclp->increment_size;
 130     if (rnmax < 0x10000) {
 131         read_info->rnmax = cpu_to_be16(rnmax);
 132     } else {
 133         read_info->rnmax = cpu_to_be16(0);
 134         read_info->rnmax2 = cpu_to_be64(rnmax);
 135     }
 136
 137     if (ipib && ipib->flags & DIAG308_FLAGS_LP_VALID) {
 138         memcpy(&read_info->loadparm, &ipib->loadparm,
 139                sizeof(read_info->loadparm));
 140     } else {
 141         s390_ipl_set_loadparm(read_info->loadparm);
 142     }
 143
 144     sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
 145 }
 146
 147 /* Provide information about the CPU */
 148 static void sclp_read_cpu_info(SCLPDevice *sclp, SCCB *sccb)
 149 {
 150     MachineState *machine = MACHINE(qdev_get_machine());
 151     ReadCpuInfo *cpu_info = (ReadCpuInfo *) sccb;
 152     int cpu_count;
 153     int required_len = SCCB_REQ_LEN(ReadCpuInfo, machine->possible_cpus->len);
 154
 155     if (be16_to_cpu(sccb->h.length) < required_len) {
 156         sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
 157         return;
 158     }
 159
 160     prepare_cpu_entries(machine, cpu_info->entries, &cpu_count);
 161     cpu_info->nr_configured = cpu_to_be16(cpu_count);
 162     cpu_info->offset_configured = cpu_to_be16(offsetof(ReadCpuInfo, entries));
 163     cpu_info->nr_standby = cpu_to_be16(0);
 164
 165     /* The standby offset is 16-byte for each CPU */
 166     cpu_info->offset_standby = cpu_to_be16(cpu_info->offset_configured
 167         + cpu_info->nr_configured*sizeof(CPUEntry));
 168
 169
 170     sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
 171 }
 172
 173 static void sclp_configure_io_adapter(SCLPDevice *sclp, SCCB *sccb,
 174                                       bool configure)
 175 {
 176     int rc;
 177
 178     if (be16_to_cpu(sccb->h.length) < 16) {
 179         rc = SCLP_RC_INSUFFICIENT_SCCB_LENGTH;
 180         goto out_err;
 181     }
 182
 183     switch (((IoaCfgSccb *)sccb)->atype) {
 184     case SCLP_RECONFIG_PCI_ATYPE:
 185         if (s390_has_feat(S390_FEAT_ZPCI)) {
 186             if (configure) {
 187                 s390_pci_sclp_configure(sccb);
 188             } else {
 189                 s390_pci_sclp_deconfigure(sccb);
 190             }
 191             return;
 192         }
 193         /* fallthrough */
 194     default:
 195         rc = SCLP_RC_ADAPTER_TYPE_NOT_RECOGNIZED;
 196     }
 197
 198  out_err:
 199     sccb->h.response_code = cpu_to_be16(rc);
 200 }
 201
 202 static void sclp_execute(SCLPDevice *sclp, SCCB *sccb, uint32_t code)
 203 {
 204     SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
 205     SCLPEventFacility *ef = sclp->event_facility;
 206     SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef);
 207
 208     switch (code & SCLP_CMD_CODE_MASK) {
 209     case SCLP_CMDW_READ_SCP_INFO:
 210     case SCLP_CMDW_READ_SCP_INFO_FORCED:
 211         sclp_c->read_SCP_info(sclp, sccb);
 212         break;
 213     case SCLP_CMDW_READ_CPU_INFO:
 214         sclp_c->read_cpu_info(sclp, sccb);
 215         break;
 216     case SCLP_CMDW_CONFIGURE_IOA:
 217         sclp_configure_io_adapter(sclp, sccb, true);
 218         break;
 219     case SCLP_CMDW_DECONFIGURE_IOA:
 220         sclp_configure_io_adapter(sclp, sccb, false);
 221         break;
 222     default:
 223         efc->command_handler(ef, sccb, code);
 224         break;
 225     }
 226 }
 227
 228 /*
 229  * We only need the address to have something valid for the
 230  * service_interrupt call.
 231  */
 232 #define SCLP_PV_DUMMY_ADDR 0x4000
 233 int sclp_service_call_protected(CPUS390XState *env, uint64_t sccb,
 234                                 uint32_t code)
 235 {
 236     SCLPDevice *sclp = get_sclp_device();
 237     SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
 238     SCCBHeader header;
 239     g_autofree SCCB *work_sccb = NULL;
 240
 241     s390_cpu_pv_mem_read(env_archcpu(env), 0, &header, sizeof(SCCBHeader));
 242
 243     work_sccb = g_malloc0(be16_to_cpu(header.length));
 244     s390_cpu_pv_mem_read(env_archcpu(env), 0, work_sccb,
 245                          be16_to_cpu(header.length));
 246
 247     if (!sclp_command_code_valid(code)) {
 248         work_sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
 249         goto out_write;
 250     }
 251
 252     if (!sccb_verify_boundary(sccb, be16_to_cpu(work_sccb->h.length))) {
 253         work_sccb->h.response_code = cpu_to_be16(SCLP_RC_SCCB_BOUNDARY_VIOLATION);
 254         goto out_write;
 255     }
 256
 257     sclp_c->execute(sclp, work_sccb, code);
 258 out_write:
 259     s390_cpu_pv_mem_write(env_archcpu(env), 0, work_sccb,
 260                           be16_to_cpu(work_sccb->h.length));
 261     sclp_c->service_interrupt(sclp, SCLP_PV_DUMMY_ADDR);
 262     return 0;
 263 }
 264
 265 int sclp_service_call(CPUS390XState *env, uint64_t sccb, uint32_t code)
 266 {
 267     SCLPDevice *sclp = get_sclp_device();
 268     SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
 269     SCCBHeader header;
 270     g_autofree SCCB *work_sccb = NULL;
 271
 272     /* first some basic checks on program checks */
 273     if (env->psw.mask & PSW_MASK_PSTATE) {
 274         return -PGM_PRIVILEGED;
 275     }
 276     if (cpu_physical_memory_is_io(sccb)) {
 277         return -PGM_ADDRESSING;
 278     }
 279     if ((sccb & ~0x1fffUL) == 0 || (sccb & ~0x1fffUL) == env->psa
 280         || (sccb & ~0x7ffffff8UL) != 0) {
 281         return -PGM_SPECIFICATION;
 282     }
 283
 284     /* the header contains the actual length of the sccb */
 285     cpu_physical_memory_read(sccb, &header, sizeof(SCCBHeader));
 286
 287     /* Valid sccb sizes */
 288     if (be16_to_cpu(header.length) < sizeof(SCCBHeader)) {
 289         return -PGM_SPECIFICATION;
 290     }
 291
 292     /*
 293      * we want to work on a private copy of the sccb, to prevent guests
 294      * from playing dirty tricks by modifying the memory content after
 295      * the host has checked the values
 296      */
 297     work_sccb = g_malloc0(be16_to_cpu(header.length));
 298     cpu_physical_memory_read(sccb, work_sccb, be16_to_cpu(header.length));
 299
 300     if (!sclp_command_code_valid(code)) {
 301         work_sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
 302         goto out_write;
 303     }
 304
 305     if (!sccb_verify_boundary(sccb, be16_to_cpu(work_sccb->h.length))) {
 306         work_sccb->h.response_code = cpu_to_be16(SCLP_RC_SCCB_BOUNDARY_VIOLATION);
 307         goto out_write;
 308     }
 309
 310     sclp_c->execute(sclp, work_sccb, code);
 311 out_write:
 312     cpu_physical_memory_write(sccb, work_sccb,
 313                               be16_to_cpu(work_sccb->h.length));
 314
 315     sclp_c->service_interrupt(sclp, sccb);
 316
 317     return 0;
 318 }
 319
 320 static void service_interrupt(SCLPDevice *sclp, uint32_t sccb)
 321 {
 322     SCLPEventFacility *ef = sclp->event_facility;
 323     SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef);
 324
 325     uint32_t param = sccb & ~3;
 326
 327     /* Indicate whether an event is still pending */
 328     param |= efc->event_pending(ef) ? 1 : 0;
 329
 330     if (!param) {
 331         /* No need to send an interrupt, there's nothing to be notified about */
 332         return;
 333     }
 334     s390_sclp_extint(param);
 335 }
 336
 337 void sclp_service_interrupt(uint32_t sccb)
 338 {
 339     SCLPDevice *sclp = get_sclp_device();
 340     SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
 341
 342     sclp_c->service_interrupt(sclp, sccb);
 343 }
 344
 345 /* qemu object creation and initialization functions */
 346
 347 void s390_sclp_init(void)
 348 {
 349     Object *new = object_new(TYPE_SCLP);
 350
 351     object_property_add_child(qdev_get_machine(), TYPE_SCLP, new);
 352     object_unref(new);
 353     qdev_realize(DEVICE(new), NULL, &error_fatal);
 354 }
 355
 356 static void sclp_realize(DeviceState *dev, Error **errp)
 357 {
 358     MachineState *machine = MACHINE(qdev_get_machine());
 359     SCLPDevice *sclp = SCLP(dev);
 360     uint64_t hw_limit;
 361     int ret;
 362
 363     /*
 364      * qdev_device_add searches the sysbus for TYPE_SCLP_EVENTS_BUS. As long
 365      * as we can't find a fitting bus via the qom tree, we have to add the
 366      * event facility to the sysbus, so e.g. a sclp console can be created.
 367      */
 368     if (!sysbus_realize(SYS_BUS_DEVICE(sclp->event_facility), errp)) {
 369         return;
 370     }
 371
 372     ret = s390_set_memory_limit(machine->maxram_size, &hw_limit);
 373     if (ret == -E2BIG) {
 374         error_setg(errp, "host supports a maximum of %" PRIu64 " GB",
 375                    hw_limit / GiB);
 376     } else if (ret) {
 377         error_setg(errp, "setting the guest size failed");
 378     }
 379 }
 380
 381 static void sclp_memory_init(SCLPDevice *sclp)
 382 {
 383     MachineState *machine = MACHINE(qdev_get_machine());
 384     MachineClass *machine_class = MACHINE_GET_CLASS(qdev_get_machine());
 385     ram_addr_t initial_mem = machine->ram_size;
 386     int increment_size = 20;
 387
 388     /* The storage increment size is a multiple of 1M and is a power of 2.
 389      * For some machine types, the number of storage increments must be
 390      * MAX_STORAGE_INCREMENTS or fewer.
 391      * The variable 'increment_size' is an exponent of 2 that can be
 392      * used to calculate the size (in bytes) of an increment. */
 393     while (machine_class->fixup_ram_size != NULL &&
 394            (initial_mem >> increment_size) > MAX_STORAGE_INCREMENTS) {
 395         increment_size++;
 396     }
 397     sclp->increment_size = increment_size;
 398 }
 399
 400 static void sclp_init(Object *obj)
 401 {
 402     SCLPDevice *sclp = SCLP(obj);
 403     Object *new;
 404
 405     new = object_new(TYPE_SCLP_EVENT_FACILITY);
 406     object_property_add_child(obj, TYPE_SCLP_EVENT_FACILITY, new);
 407     object_unref(new);
 408     sclp->event_facility = EVENT_FACILITY(new);
 409
 410     sclp_memory_init(sclp);
 411 }
 412
 413 static void sclp_class_init(ObjectClass *oc, void *data)
 414 {
 415     SCLPDeviceClass *sc = SCLP_CLASS(oc);
 416     DeviceClass *dc = DEVICE_CLASS(oc);
 417
 418     dc->desc = "SCLP (Service-Call Logical Processor)";
 419     dc->realize = sclp_realize;
 420     dc->hotpluggable = false;
 421     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
 422     /*
 423      * Reason: Creates TYPE_SCLP_EVENT_FACILITY in sclp_init
 424      * which is a non-pluggable sysbus device
 425      */
 426     dc->user_creatable = false;
 427
 428     sc->read_SCP_info = read_SCP_info;
 429     sc->read_cpu_info = sclp_read_cpu_info;
 430     sc->execute = sclp_execute;
 431     sc->service_interrupt = service_interrupt;
 432 }
 433
 434 static TypeInfo sclp_info = {
 435     .name = TYPE_SCLP,
 436     .parent = TYPE_DEVICE,
 437     .instance_init = sclp_init,
 438     .instance_size = sizeof(SCLPDevice),
 439     .class_init = sclp_class_init,
 440     .class_size = sizeof(SCLPDeviceClass),
 441 };
 442
 443 static void register_types(void)
 444 {
 445     type_register_static(&sclp_info);
 446 }
 447 type_init(register_types);