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 return;
186 }
187 if (be16_to_cpu(sccb->h.length) < 8) {
188 sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
189 return;
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}
200
201static uint16_t handle_sccb_read_events(SCLPEventFacility *ef, SCCB *sccb,
202 sccb_mask_t mask)
203{
204 uint16_t rc;
205 int slen;
206 unsigned elen;
207 BusChild *kid;
208 SCLPEvent *event;
209 SCLPEventClass *ec;
210 EventBufferHeader *event_buf;
211 ReadEventData *red = (ReadEventData *) sccb;
212
213 event_buf = &red->ebh;
214 event_buf->length = 0;
215 slen = sizeof(sccb->data);
216
217 rc = SCLP_RC_NO_EVENT_BUFFERS_STORED;
218
219 QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
220 DeviceState *qdev = kid->child;
221 event = (SCLPEvent *) qdev;
222 ec = SCLP_EVENT_GET_CLASS(event);
223
224 if (mask & ec->get_send_mask()) {
225 if (ec->read_event_data(event, event_buf, &slen)) {
226 elen = be16_to_cpu(event_buf->length);
227 event_buf = (EventBufferHeader *) ((char *)event_buf + elen);
228 rc = SCLP_RC_NORMAL_COMPLETION;
229 }
230 }
231 }
232
233 if (sccb->h.control_mask[2] & SCLP_VARIABLE_LENGTH_RESPONSE) {
234
235 sccb->h.control_mask[2] &= ~SCLP_VARIABLE_LENGTH_RESPONSE;
236
237 sccb->h.length = cpu_to_be16(SCCB_SIZE - slen);
238 }
239 return rc;
240}
241
242
243static void copy_mask(uint8_t *dst, uint8_t *src, uint16_t dst_len,
244 uint16_t src_len)
245{
246 int i;
247
248 for (i = 0; i < dst_len; i++) {
249 dst[i] = i < src_len ? src[i] : 0;
250 }
251}
252
253static void read_event_data(SCLPEventFacility *ef, SCCB *sccb)
254{
255 sccb_mask_t sclp_active_selection_mask;
256 sccb_mask_t sclp_cp_receive_mask;
257
258 ReadEventData *red = (ReadEventData *) sccb;
259
260 if (be16_to_cpu(sccb->h.length) != SCCB_SIZE) {
261 sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
262 return;
263 }
264
265 switch (sccb->h.function_code) {
266 case SCLP_UNCONDITIONAL_READ:
267 sccb->h.response_code = cpu_to_be16(
268 handle_sccb_read_events(ef, sccb, ef->receive_mask));
269 break;
270 case SCLP_SELECTIVE_READ:
271
272 sclp_cp_receive_mask = ef->receive_mask;
273
274 copy_mask((uint8_t *)&sclp_active_selection_mask, (uint8_t *)&red->mask,
275 sizeof(sclp_active_selection_mask), ef->mask_length);
276 sclp_active_selection_mask = be64_to_cpu(sclp_active_selection_mask);
277 if (!sclp_cp_receive_mask ||
278 (sclp_active_selection_mask & ~sclp_cp_receive_mask)) {
279 sccb->h.response_code =
280 cpu_to_be16(SCLP_RC_INVALID_SELECTION_MASK);
281 } else {
282 sccb->h.response_code = cpu_to_be16(
283 handle_sccb_read_events(ef, sccb, sclp_active_selection_mask));
284 }
285 break;
286 default:
287 sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION);
288 }
289}
290
291static void write_event_mask(SCLPEventFacility *ef, SCCB *sccb)
292{
293 WriteEventMask *we_mask = (WriteEventMask *) sccb;
294 uint16_t mask_length = be16_to_cpu(we_mask->mask_length);
295 sccb_mask_t tmp_mask;
296
297 if (!mask_length || (mask_length > SCLP_EVENT_MASK_LEN_MAX) ||
298 ((mask_length != 4) && !ef->allow_all_mask_sizes)) {
299 sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_MASK_LENGTH);
300 return;
301 }
302
303
304
305
306
307
308
309
310
311 copy_mask((uint8_t *)&tmp_mask, WEM_CP_RECEIVE_MASK(we_mask, mask_length),
312 sizeof(tmp_mask), mask_length);
313 ef->receive_mask = be64_to_cpu(tmp_mask);
314
315
316 tmp_mask = cpu_to_be64(get_host_receive_mask(ef));
317 copy_mask(WEM_RECEIVE_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
318 mask_length, sizeof(tmp_mask));
319 tmp_mask = cpu_to_be64(get_host_send_mask(ef));
320 copy_mask(WEM_SEND_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
321 mask_length, sizeof(tmp_mask));
322
323 sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
324 ef->mask_length = mask_length;
325}
326
327
328
329#define TYPE_SCLP_EVENTS_BUS "s390-sclp-events-bus"
330
331static void sclp_events_bus_realize(BusState *bus, Error **errp)
332{
333 Error *err = NULL;
334 BusChild *kid;
335
336
337 QTAILQ_FOREACH(kid, &bus->children, sibling) {
338 DeviceState *dev = kid->child;
339
340 object_property_set_bool(OBJECT(dev), true, "realized", &err);
341 if (err) {
342 error_propagate(errp, err);
343 return;
344 }
345 }
346}
347
348static void sclp_events_bus_class_init(ObjectClass *klass, void *data)
349{
350 BusClass *bc = BUS_CLASS(klass);
351
352 bc->realize = sclp_events_bus_realize;
353}
354
355static const TypeInfo sclp_events_bus_info = {
356 .name = TYPE_SCLP_EVENTS_BUS,
357 .parent = TYPE_BUS,
358 .class_init = sclp_events_bus_class_init,
359};
360
361static void command_handler(SCLPEventFacility *ef, SCCB *sccb, uint64_t code)
362{
363 switch (code & SCLP_CMD_CODE_MASK) {
364 case SCLP_CMD_READ_EVENT_DATA:
365 read_event_data(ef, sccb);
366 break;
367 case SCLP_CMD_WRITE_EVENT_DATA:
368 write_event_data(ef, sccb);
369 break;
370 case SCLP_CMD_WRITE_EVENT_MASK:
371 write_event_mask(ef, sccb);
372 break;
373 }
374}
375
376static bool vmstate_event_facility_mask64_needed(void *opaque)
377{
378 SCLPEventFacility *ef = opaque;
379
380 return (ef->receive_mask & 0xFFFFFFFF) != 0;
381}
382
383static bool vmstate_event_facility_mask_length_needed(void *opaque)
384{
385 SCLPEventFacility *ef = opaque;
386
387 return ef->allow_all_mask_sizes;
388}
389
390static const VMStateDescription vmstate_event_facility_mask64 = {
391 .name = "vmstate-event-facility/mask64",
392 .version_id = 0,
393 .minimum_version_id = 0,
394 .needed = vmstate_event_facility_mask64_needed,
395 .fields = (VMStateField[]) {
396 VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_LOWER], SCLPEventFacility),
397 VMSTATE_END_OF_LIST()
398 }
399};
400
401static const VMStateDescription vmstate_event_facility_mask_length = {
402 .name = "vmstate-event-facility/mask_length",
403 .version_id = 0,
404 .minimum_version_id = 0,
405 .needed = vmstate_event_facility_mask_length_needed,
406 .fields = (VMStateField[]) {
407 VMSTATE_UINT16(mask_length, SCLPEventFacility),
408 VMSTATE_END_OF_LIST()
409 }
410};
411
412static const VMStateDescription vmstate_event_facility = {
413 .name = "vmstate-event-facility",
414 .version_id = 0,
415 .minimum_version_id = 0,
416 .fields = (VMStateField[]) {
417 VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_UPPER], SCLPEventFacility),
418 VMSTATE_END_OF_LIST()
419 },
420 .subsections = (const VMStateDescription * []) {
421 &vmstate_event_facility_mask64,
422 &vmstate_event_facility_mask_length,
423 NULL
424 }
425};
426
427static void sclp_event_set_allow_all_mask_sizes(Object *obj, bool value,
428 Error **errp)
429{
430 SCLPEventFacility *ef = (SCLPEventFacility *)obj;
431
432 ef->allow_all_mask_sizes = value;
433}
434
435static bool sclp_event_get_allow_all_mask_sizes(Object *obj, Error **errp)
436{
437 SCLPEventFacility *ef = (SCLPEventFacility *)obj;
438
439 return ef->allow_all_mask_sizes;
440}
441
442static void init_event_facility(Object *obj)
443{
444 SCLPEventFacility *event_facility = EVENT_FACILITY(obj);
445 DeviceState *sdev = DEVICE(obj);
446 Object *new;
447
448 event_facility->mask_length = 4;
449 event_facility->allow_all_mask_sizes = true;
450 object_property_add_bool(obj, "allow_all_mask_sizes",
451 sclp_event_get_allow_all_mask_sizes,
452 sclp_event_set_allow_all_mask_sizes, NULL);
453
454 qbus_create_inplace(&event_facility->sbus, sizeof(event_facility->sbus),
455 TYPE_SCLP_EVENTS_BUS, sdev, NULL);
456
457 new = object_new(TYPE_SCLP_QUIESCE);
458 object_property_add_child(obj, TYPE_SCLP_QUIESCE, new, NULL);
459 object_unref(new);
460 qdev_set_parent_bus(DEVICE(new), BUS(&event_facility->sbus));
461
462 new = object_new(TYPE_SCLP_CPU_HOTPLUG);
463 object_property_add_child(obj, TYPE_SCLP_CPU_HOTPLUG, new, NULL);
464 object_unref(new);
465 qdev_set_parent_bus(DEVICE(new), BUS(&event_facility->sbus));
466
467}
468
469static void reset_event_facility(DeviceState *dev)
470{
471 SCLPEventFacility *sdev = EVENT_FACILITY(dev);
472
473 sdev->receive_mask = 0;
474}
475
476static void init_event_facility_class(ObjectClass *klass, void *data)
477{
478 SysBusDeviceClass *sbdc = SYS_BUS_DEVICE_CLASS(klass);
479 DeviceClass *dc = DEVICE_CLASS(sbdc);
480 SCLPEventFacilityClass *k = EVENT_FACILITY_CLASS(dc);
481
482 dc->reset = reset_event_facility;
483 dc->vmsd = &vmstate_event_facility;
484 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
485 k->command_handler = command_handler;
486 k->event_pending = event_pending;
487}
488
489static const TypeInfo sclp_event_facility_info = {
490 .name = TYPE_SCLP_EVENT_FACILITY,
491 .parent = TYPE_SYS_BUS_DEVICE,
492 .instance_init = init_event_facility,
493 .instance_size = sizeof(SCLPEventFacility),
494 .class_init = init_event_facility_class,
495 .class_size = sizeof(SCLPEventFacilityClass),
496};
497
498static void event_realize(DeviceState *qdev, Error **errp)
499{
500 SCLPEvent *event = SCLP_EVENT(qdev);
501 SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event);
502
503 if (child->init) {
504 int rc = child->init(event);
505 if (rc < 0) {
506 error_setg(errp, "SCLP event initialization failed.");
507 return;
508 }
509 }
510}
511
512static void event_class_init(ObjectClass *klass, void *data)
513{
514 DeviceClass *dc = DEVICE_CLASS(klass);
515
516 dc->bus_type = TYPE_SCLP_EVENTS_BUS;
517 dc->realize = event_realize;
518}
519
520static const TypeInfo sclp_event_type_info = {
521 .name = TYPE_SCLP_EVENT,
522 .parent = TYPE_DEVICE,
523 .instance_size = sizeof(SCLPEvent),
524 .class_init = event_class_init,
525 .class_size = sizeof(SCLPEventClass),
526 .abstract = true,
527};
528
529static void register_types(void)
530{
531 type_register_static(&sclp_events_bus_info);
532 type_register_static(&sclp_event_facility_info);
533 type_register_static(&sclp_event_type_info);
534}
535
536type_init(register_types)
537
538BusState *sclp_get_event_facility_bus(void)
539{
540 Object *busobj;
541 SCLPEventsBus *sbus;
542
543 busobj = object_resolve_path_type("", TYPE_SCLP_EVENTS_BUS, NULL);
544 sbus = OBJECT_CHECK(SCLPEventsBus, busobj, TYPE_SCLP_EVENTS_BUS);
545 if (!sbus) {
546 return NULL;
547 }
548
549 return &sbus->qbus;
550}
551