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