qemu

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);
474