1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "qemu/osdep.h"
19#include "qapi/error.h"
20#include "qemu/module.h"
21
22#include "hw/s390x/sclp.h"
23#include "migration/vmstate.h"
24#include "hw/s390x/event-facility.h"
25
26typedef struct SCLPEventsBus {
27 BusState qbus;
28} SCLPEventsBus;
29
30
31#ifdef HOST_WORDS_BIGENDIAN
32#define RECV_MASK_LOWER 1
33#define RECV_MASK_UPPER 0
34#else
35#define RECV_MASK_LOWER 0
36#define RECV_MASK_UPPER 1
37#endif
38
39struct SCLPEventFacility {
40 SysBusDevice parent_obj;
41 SCLPEventsBus sbus;
42
43 union {
44 uint32_t receive_mask_pieces[2];
45 sccb_mask_t receive_mask;
46 };
47
48
49
50
51
52
53 bool allow_all_mask_sizes;
54
55 uint16_t mask_length;
56};
57
58
59static bool event_pending(SCLPEventFacility *ef)
60{
61 BusChild *kid;
62 SCLPEvent *event;
63 SCLPEventClass *event_class;
64
65 QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
66 DeviceState *qdev = kid->child;
67 event = DO_UPCAST(SCLPEvent, qdev, qdev);
68 event_class = SCLP_EVENT_GET_CLASS(event);
69 if (event->event_pending &&
70 event_class->get_send_mask() & ef->receive_mask) {
71 return true;
72 }
73 }
74 return false;
75}
76
77static sccb_mask_t get_host_send_mask(SCLPEventFacility *ef)
78{
79 sccb_mask_t mask;
80 BusChild *kid;
81 SCLPEventClass *child;
82
83 mask = 0;
84
85 QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
86 DeviceState *qdev = kid->child;
87 child = SCLP_EVENT_GET_CLASS((SCLPEvent *) qdev);
88 mask |= child->get_send_mask();
89 }
90 return mask;
91}
92
93static sccb_mask_t get_host_receive_mask(SCLPEventFacility *ef)
94{
95 sccb_mask_t mask;
96 BusChild *kid;
97 SCLPEventClass *child;
98
99 mask = 0;
100
101 QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
102 DeviceState *qdev = kid->child;
103 child = SCLP_EVENT_GET_CLASS((SCLPEvent *) qdev);
104 mask |= child->get_receive_mask();
105 }
106 return mask;
107}
108
109static uint16_t write_event_length_check(SCCB *sccb)
110{
111 int slen;
112 unsigned elen = 0;
113 EventBufferHeader *event;
114 WriteEventData *wed = (WriteEventData *) sccb;
115
116 event = (EventBufferHeader *) &wed->ebh;
117 for (slen = sccb_data_len(sccb); slen > 0; slen -= elen) {
118 elen = be16_to_cpu(event->length);
119 if (elen < sizeof(*event) || elen > slen) {
120 return SCLP_RC_EVENT_BUFFER_SYNTAX_ERROR;
121 }
122 event = (void *) event + elen;
123 }
124 if (slen) {
125 return SCLP_RC_INCONSISTENT_LENGTHS;
126 }
127 return SCLP_RC_NORMAL_COMPLETION;
128}
129
130static uint16_t handle_write_event_buf(SCLPEventFacility *ef,
131 EventBufferHeader *event_buf, SCCB *sccb)
132{
133 uint16_t rc;
134 BusChild *kid;
135 SCLPEvent *event;
136 SCLPEventClass *ec;
137
138 rc = SCLP_RC_INVALID_FUNCTION;
139
140 QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
141 DeviceState *qdev = kid->child;
142 event = (SCLPEvent *) qdev;
143 ec = SCLP_EVENT_GET_CLASS(event);
144
145 if (ec->write_event_data &&
146 ec->can_handle_event(event_buf->type)) {
147 rc = ec->write_event_data(event, event_buf);
148 break;
149 }
150 }
151 return rc;
152}
153
154static uint16_t handle_sccb_write_events(SCLPEventFacility *ef, SCCB *sccb)
155{
156 uint16_t rc;
157 int slen;
158 unsigned elen = 0;
159 EventBufferHeader *event_buf;
160 WriteEventData *wed = (WriteEventData *) sccb;
161
162 event_buf = &wed->ebh;
163 rc = SCLP_RC_NORMAL_COMPLETION;
164
165
166 for (slen = sccb_data_len(sccb); slen > 0; slen -= elen) {
167 elen = be16_to_cpu(event_buf->length);
168
169
170
171 if (rc != SCLP_RC_NORMAL_COMPLETION) {
172 event_buf->flags &= ~(SCLP_EVENT_BUFFER_ACCEPTED);
173 } else {
174 rc = handle_write_event_buf(ef, event_buf, sccb);
175 }
176 event_buf = (void *) event_buf + elen;
177 }
178 return rc;
179}
180
181static void write_event_data(SCLPEventFacility *ef, SCCB *sccb)
182{
183 if (sccb->h.function_code != SCLP_FC_NORMAL_WRITE) {
184 sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION);
185 goto out;
186 }
187 if (be16_to_cpu(sccb->h.length) < 8) {
188 sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
189 goto out;
190 }
191
192 sccb->h.response_code = cpu_to_be16(write_event_length_check(sccb));
193
194
195 if (sccb->h.response_code == be16_to_cpu(SCLP_RC_NORMAL_COMPLETION)) {
196 sccb->h.response_code =
197 cpu_to_be16(handle_sccb_write_events(ef, sccb));
198 }
199
200out:
201 return;
202}
203
204static uint16_t handle_sccb_read_events(SCLPEventFacility *ef, SCCB *sccb,
205 sccb_mask_t mask)
206{
207 uint16_t rc;
208 int slen;
209 unsigned elen;
210 BusChild *kid;
211 SCLPEvent *event;
212 SCLPEventClass *ec;
213 EventBufferHeader *event_buf;
214 ReadEventData *red = (ReadEventData *) sccb;
215
216 event_buf = &red->ebh;
217 event_buf->length = 0;
218 slen = sizeof(sccb->data);
219
220 rc = SCLP_RC_NO_EVENT_BUFFERS_STORED;
221
222 QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
223 DeviceState *qdev = kid->child;
224 event = (SCLPEvent *) qdev;
225 ec = SCLP_EVENT_GET_CLASS(event);
226
227 if (mask & ec->get_send_mask()) {
228 if (ec->read_event_data(event, event_buf, &slen)) {
229 elen = be16_to_cpu(event_buf->length);
230 event_buf = (EventBufferHeader *) ((char *)event_buf + elen);
231 rc = SCLP_RC_NORMAL_COMPLETION;
232 }
233 }
234 }
235
236 if (sccb->h.control_mask[2] & SCLP_VARIABLE_LENGTH_RESPONSE) {
237
238 sccb->h.control_mask[2] &= ~SCLP_VARIABLE_LENGTH_RESPONSE;
239
240 sccb->h.length = cpu_to_be16(SCCB_SIZE - slen);
241 }
242 return rc;
243}
244
245
246static void copy_mask(uint8_t *dst, uint8_t *src, uint16_t dst_len,
247 uint16_t src_len)
248{
249 int i;
250
251 for (i = 0; i < dst_len; i++) {
252 dst[i] = i < src_len ? src[i] : 0;
253 }
254}
255
256static void read_event_data(SCLPEventFacility *ef, SCCB *sccb)
257{
258 sccb_mask_t sclp_active_selection_mask;
259 sccb_mask_t sclp_cp_receive_mask;
260
261 ReadEventData *red = (ReadEventData *) sccb;
262
263 if (be16_to_cpu(sccb->h.length) != SCCB_SIZE) {
264 sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
265 goto out;
266 }
267
268 sclp_cp_receive_mask = ef->receive_mask;
269
270
271 switch (sccb->h.function_code) {
272 case SCLP_UNCONDITIONAL_READ:
273 sclp_active_selection_mask = sclp_cp_receive_mask;
274 break;
275 case SCLP_SELECTIVE_READ:
276 copy_mask((uint8_t *)&sclp_active_selection_mask, (uint8_t *)&red->mask,
277 sizeof(sclp_active_selection_mask), ef->mask_length);
278 sclp_active_selection_mask = be64_to_cpu(sclp_active_selection_mask);
279 if (!sclp_cp_receive_mask ||
280 (sclp_active_selection_mask & ~sclp_cp_receive_mask)) {
281 sccb->h.response_code =
282 cpu_to_be16(SCLP_RC_INVALID_SELECTION_MASK);
283 goto out;
284 }
285 break;
286 default:
287 sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION);
288 goto out;
289 }
290 sccb->h.response_code = cpu_to_be16(
291 handle_sccb_read_events(ef, sccb, sclp_active_selection_mask));
292
293out:
294 return;
295}
296
297static void write_event_mask(SCLPEventFacility *ef, SCCB *sccb)
298{
299 WriteEventMask *we_mask = (WriteEventMask *) sccb;
300 uint16_t mask_length = be16_to_cpu(we_mask->mask_length);
301 sccb_mask_t tmp_mask;
302
303 if (!mask_length || (mask_length > SCLP_EVENT_MASK_LEN_MAX) ||
304 ((mask_length != 4) && !ef->allow_all_mask_sizes)) {
305 sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_MASK_LENGTH);
306 goto out;
307 }
308
309
310
311
312
313
314
315
316
317 copy_mask((uint8_t *)&tmp_mask, WEM_CP_RECEIVE_MASK(we_mask, mask_length),
318 sizeof(tmp_mask), mask_length);
319 ef->receive_mask = be64_to_cpu(tmp_mask);
320
321
322 tmp_mask = cpu_to_be64(get_host_receive_mask(ef));
323 copy_mask(WEM_RECEIVE_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
324 mask_length, sizeof(tmp_mask));
325 tmp_mask = cpu_to_be64(get_host_send_mask(ef));
326 copy_mask(WEM_SEND_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
327 mask_length, sizeof(tmp_mask));
328
329 sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
330 ef->mask_length = mask_length;
331
332out:
333 return;
334}
335
336
337
338#define TYPE_SCLP_EVENTS_BUS "s390-sclp-events-bus"
339
340static void sclp_events_bus_realize(BusState *bus, Error **errp)
341{
342 BusChild *kid;
343
344
345 QTAILQ_FOREACH(kid, &bus->children, sibling) {
346 DeviceState *dev = kid->child;
347
348 object_property_set_bool(OBJECT(dev), true, "realized", errp);
349 if (*errp) {
350 return;
351 }
352 }
353}
354
355static void sclp_events_bus_class_init(ObjectClass *klass, void *data)
356{
357 BusClass *bc = BUS_CLASS(klass);
358
359 bc->realize = sclp_events_bus_realize;
360}
361
362static const TypeInfo sclp_events_bus_info = {
363 .name = TYPE_SCLP_EVENTS_BUS,
364 .parent = TYPE_BUS,
365 .class_init = sclp_events_bus_class_init,
366};
367
368static void command_handler(SCLPEventFacility *ef, SCCB *sccb, uint64_t code)
369{
370 switch (code & SCLP_CMD_CODE_MASK) {
371 case SCLP_CMD_READ_EVENT_DATA:
372 read_event_data(ef, sccb);
373 break;
374 case SCLP_CMD_WRITE_EVENT_DATA:
375 write_event_data(ef, sccb);
376 break;
377 case SCLP_CMD_WRITE_EVENT_MASK:
378 write_event_mask(ef, sccb);
379 break;
380 }
381}
382
383static bool vmstate_event_facility_mask64_needed(void *opaque)
384{
385 SCLPEventFacility *ef = opaque;
386
387 return (ef->receive_mask & 0xFFFFFFFF) != 0;
388}
389
390static bool vmstate_event_facility_mask_length_needed(void *opaque)
391{
392 SCLPEventFacility *ef = opaque;
393
394 return ef->allow_all_mask_sizes;
395}
396
397static const VMStateDescription vmstate_event_facility_mask64 = {
398 .name = "vmstate-event-facility/mask64",
399 .version_id = 0,
400 .minimum_version_id = 0,
401 .needed = vmstate_event_facility_mask64_needed,
402 .fields = (VMStateField[]) {
403 VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_LOWER], SCLPEventFacility),
404 VMSTATE_END_OF_LIST()
405 }
406};
407
408static const VMStateDescription vmstate_event_facility_mask_length = {
409 .name = "vmstate-event-facility/mask_length",
410 .version_id = 0,
411 .minimum_version_id = 0,
412 .needed = vmstate_event_facility_mask_length_needed,
413 .fields = (VMStateField[]) {
414 VMSTATE_UINT16(mask_length, SCLPEventFacility),
415 VMSTATE_END_OF_LIST()
416 }
417};
418
419static const VMStateDescription vmstate_event_facility = {
420 .name = "vmstate-event-facility",
421 .version_id = 0,
422 .minimum_version_id = 0,
423 .fields = (VMStateField[]) {
424 VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_UPPER], SCLPEventFacility),
425 VMSTATE_END_OF_LIST()
426 },
427 .subsections = (const VMStateDescription * []) {
428 &vmstate_event_facility_mask64,
429 &vmstate_event_facility_mask_length,
430 NULL
431 }
432};
433
434static void sclp_event_set_allow_all_mask_sizes(Object *obj, bool value,
435 Error **errp)
436{
437 SCLPEventFacility *ef = (SCLPEventFacility *)obj;
438
439 ef->allow_all_mask_sizes = value;
440}
441
442static bool sclp_event_get_allow_all_mask_sizes(Object *obj, Error **e)
443{
444 SCLPEventFacility *ef = (SCLPEventFacility *)obj;
445
446 return ef->allow_all_mask_sizes;
447}
448
449static void init_event_facility(Object *obj)
450{
451 SCLPEventFacility *event_facility = EVENT_FACILITY(obj);
452 DeviceState *sdev = DEVICE(obj);
453 Object *new;
454
455 event_facility->mask_length = 4;
456 event_facility->allow_all_mask_sizes = true;
457 object_property_add_bool(obj, "allow_all_mask_sizes",
458 sclp_event_get_allow_all_mask_sizes,
459 sclp_event_set_allow_all_mask_sizes, NULL);
460
461 qbus_create_inplace(&event_facility->sbus, sizeof(event_facility->sbus),
462 TYPE_SCLP_EVENTS_BUS, sdev, NULL);
463
464 new = object_new(TYPE_SCLP_QUIESCE);
465 object_property_add_child(obj, TYPE_SCLP_QUIESCE, new, NULL);
466 object_unref(new);
467 qdev_set_parent_bus(DEVICE(new), BUS(&event_facility->sbus));
468
469 new = object_new(TYPE_SCLP_CPU_HOTPLUG);
470 object_property_add_child(obj, TYPE_SCLP_CPU_HOTPLUG, new, NULL);
471 object_unref(new);
472 qdev_set_parent_bus(DEVICE(new), BUS(&event_facility->sbus));
473
474}
475
476static void reset_event_facility(DeviceState *dev)
477{
478 SCLPEventFacility *sdev = EVENT_FACILITY(dev);
479
480 sdev->receive_mask = 0;
481}
482
483static void init_event_facility_class(ObjectClass *klass, void *data)
484{
485 SysBusDeviceClass *sbdc = SYS_BUS_DEVICE_CLASS(klass);
486 DeviceClass *dc = DEVICE_CLASS(sbdc);
487 SCLPEventFacilityClass *k = EVENT_FACILITY_CLASS(dc);
488
489 dc->reset = reset_event_facility;
490 dc->vmsd = &vmstate_event_facility;
491 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
492 k->command_handler = command_handler;
493 k->event_pending = event_pending;
494}
495
496static const TypeInfo sclp_event_facility_info = {
497 .name = TYPE_SCLP_EVENT_FACILITY,
498 .parent = TYPE_SYS_BUS_DEVICE,
499 .instance_init = init_event_facility,
500 .instance_size = sizeof(SCLPEventFacility),
501 .class_init = init_event_facility_class,
502 .class_size = sizeof(SCLPEventFacilityClass),
503};
504
505static void event_realize(DeviceState *qdev, Error **errp)
506{
507 SCLPEvent *event = SCLP_EVENT(qdev);
508 SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event);
509
510 if (child->init) {
511 int rc = child->init(event);
512 if (rc < 0) {
513 error_setg(errp, "SCLP event initialization failed.");
514 return;
515 }
516 }
517}
518
519static void event_class_init(ObjectClass *klass, void *data)
520{
521 DeviceClass *dc = DEVICE_CLASS(klass);
522
523 dc->bus_type = TYPE_SCLP_EVENTS_BUS;
524 dc->realize = event_realize;
525}
526
527static const TypeInfo sclp_event_type_info = {
528 .name = TYPE_SCLP_EVENT,
529 .parent = TYPE_DEVICE,
530 .instance_size = sizeof(SCLPEvent),
531 .class_init = event_class_init,
532 .class_size = sizeof(SCLPEventClass),
533 .abstract = true,
534};
535
536static void register_types(void)
537{
538 type_register_static(&sclp_events_bus_info);
539 type_register_static(&sclp_event_facility_info);
540 type_register_static(&sclp_event_type_info);
541}
542
543type_init(register_types)
544
545BusState *sclp_get_event_facility_bus(void)
546{
547 Object *busobj;
548 SCLPEventsBus *sbus;
549
550 busobj = object_resolve_path_type("", TYPE_SCLP_EVENTS_BUS, NULL);
551 sbus = OBJECT_CHECK(SCLPEventsBus, busobj, TYPE_SCLP_EVENTS_BUS);
552 if (!sbus) {
553 return NULL;
554 }
555
556 return &sbus->qbus;
557}
558