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