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
get_sclp_device(void)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
sclp_command_code_valid(uint32_t code)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
sccb_verify_boundary(uint64_t sccb_addr,uint16_t sccb_len,uint32_t code)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
prepare_cpu_entries(MachineState * ms,CPUEntry * entry,int * count)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
ext_len_sccb_supported(SCCBHeader header)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 */
read_SCP_info(SCLPDevice * sclp,SCCB * sccb)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 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 /*
165 * We don't support standby memory. maxram_size is used for sizing the
166 * memory device region, which is not exposed through SCLP but through
167 * diag500.
168 */
169 rnmax = machine->ram_size >> sclp->increment_size;
170 if (rnmax < 0x10000) {
171 read_info->rnmax = cpu_to_be16(rnmax);
172 } else {
173 read_info->rnmax = cpu_to_be16(0);
174 read_info->rnmax2 = cpu_to_be64(rnmax);
175 }
176
177 s390_ipl_convert_loadparm((char *)S390_CCW_MACHINE(machine)->loadparm,
178 read_info->loadparm);
179
180 sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
181 }
182
183 /* Provide information about the CPU */
sclp_read_cpu_info(SCLPDevice * sclp,SCCB * sccb)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
sclp_configure_io_adapter(SCLPDevice * sclp,SCCB * sccb,bool configure)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
sclp_execute(SCLPDevice * sclp,SCCB * sccb,uint32_t code)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
sclp_service_call_protected(S390CPU * cpu,uint64_t sccb,uint32_t code)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
sclp_service_call(S390CPU * cpu,uint64_t sccb,uint32_t code)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
service_interrupt(SCLPDevice * sclp,uint32_t sccb)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
sclp_service_interrupt(uint32_t sccb)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 */
sclp_realize(DeviceState * dev,Error ** errp)381 static void sclp_realize(DeviceState *dev, Error **errp)
382 {
383 SCLPDevice *sclp = SCLP(dev);
384
385 /*
386 * qdev_device_add searches the sysbus for TYPE_SCLP_EVENTS_BUS. As long
387 * as we can't find a fitting bus via the qom tree, we have to add the
388 * event facility to the sysbus, so e.g. a sclp console can be created.
389 */
390 if (!sysbus_realize(SYS_BUS_DEVICE(sclp->event_facility), errp)) {
391 return;
392 }
393 }
394
sclp_memory_init(SCLPDevice * sclp)395 static void sclp_memory_init(SCLPDevice *sclp)
396 {
397 MachineState *machine = MACHINE(qdev_get_machine());
398 MachineClass *machine_class = MACHINE_GET_CLASS(qdev_get_machine());
399 ram_addr_t initial_mem = machine->ram_size;
400 int increment_size = 20;
401
402 /* The storage increment size is a multiple of 1M and is a power of 2.
403 * For some machine types, the number of storage increments must be
404 * MAX_STORAGE_INCREMENTS or fewer.
405 * The variable 'increment_size' is an exponent of 2 that can be
406 * used to calculate the size (in bytes) of an increment. */
407 while (machine_class->fixup_ram_size != NULL &&
408 (initial_mem >> increment_size) > MAX_STORAGE_INCREMENTS) {
409 increment_size++;
410 }
411 sclp->increment_size = increment_size;
412 }
413
sclp_init(Object * obj)414 static void sclp_init(Object *obj)
415 {
416 SCLPDevice *sclp = SCLP(obj);
417 Object *new;
418
419 new = object_new(TYPE_SCLP_EVENT_FACILITY);
420 object_property_add_child(obj, TYPE_SCLP_EVENT_FACILITY, new);
421 object_unref(new);
422 sclp->event_facility = EVENT_FACILITY(new);
423
424 sclp_memory_init(sclp);
425 }
426
sclp_class_init(ObjectClass * oc,const void * data)427 static void sclp_class_init(ObjectClass *oc, const void *data)
428 {
429 SCLPDeviceClass *sc = SCLP_CLASS(oc);
430 DeviceClass *dc = DEVICE_CLASS(oc);
431
432 dc->desc = "SCLP (Service-Call Logical Processor)";
433 dc->realize = sclp_realize;
434 dc->hotpluggable = false;
435 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
436 /*
437 * Reason: Creates TYPE_SCLP_EVENT_FACILITY in sclp_init
438 * which is a non-pluggable sysbus device
439 */
440 dc->user_creatable = false;
441
442 sc->read_SCP_info = read_SCP_info;
443 sc->read_cpu_info = sclp_read_cpu_info;
444 sc->execute = sclp_execute;
445 sc->service_interrupt = service_interrupt;
446 }
447
448 static const TypeInfo sclp_info = {
449 .name = TYPE_SCLP,
450 .parent = TYPE_DEVICE,
451 .instance_init = sclp_init,
452 .instance_size = sizeof(SCLPDevice),
453 .class_init = sclp_class_init,
454 .class_size = sizeof(SCLPDeviceClass),
455 };
456
register_types(void)457 static void register_types(void)
458 {
459 type_register_static(&sclp_info);
460 }
461 type_init(register_types);
462