1 /* 2 * SCLP 3 * Event Facility 4 * handles SCLP event types 5 * - Signal Quiesce - system power down 6 * - ASCII Console Data - VT220 read and write 7 * 8 * Copyright IBM, Corp. 2012 9 * 10 * Authors: 11 * Heinz Graalfs <graalfs@de.ibm.com> 12 * 13 * This work is licensed under the terms of the GNU GPL, version 2 or (at your 14 * option) any later version. See the COPYING file in the top-level directory. 15 * 16 */ 17 18 #include "sysemu/sysemu.h" 19 20 #include "hw/s390x/sclp.h" 21 #include "hw/s390x/event-facility.h" 22 23 typedef struct SCLPEventsBus { 24 BusState qbus; 25 } SCLPEventsBus; 26 27 struct SCLPEventFacility { 28 SysBusDevice parent_obj; 29 SCLPEventsBus sbus; 30 /* guest' receive mask */ 31 unsigned int receive_mask; 32 }; 33 34 static SCLPEvent cpu_hotplug; 35 36 /* return true if any child has event pending set */ 37 static bool event_pending(SCLPEventFacility *ef) 38 { 39 BusChild *kid; 40 SCLPEvent *event; 41 SCLPEventClass *event_class; 42 43 QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) { 44 DeviceState *qdev = kid->child; 45 event = DO_UPCAST(SCLPEvent, qdev, qdev); 46 event_class = SCLP_EVENT_GET_CLASS(event); 47 if (event->event_pending && 48 event_class->get_send_mask() & ef->receive_mask) { 49 return true; 50 } 51 } 52 return false; 53 } 54 55 static unsigned int get_host_send_mask(SCLPEventFacility *ef) 56 { 57 unsigned int mask; 58 BusChild *kid; 59 SCLPEventClass *child; 60 61 mask = 0; 62 63 QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) { 64 DeviceState *qdev = kid->child; 65 child = SCLP_EVENT_GET_CLASS((SCLPEvent *) qdev); 66 mask |= child->get_send_mask(); 67 } 68 return mask; 69 } 70 71 static unsigned int get_host_receive_mask(SCLPEventFacility *ef) 72 { 73 unsigned int mask; 74 BusChild *kid; 75 SCLPEventClass *child; 76 77 mask = 0; 78 79 QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) { 80 DeviceState *qdev = kid->child; 81 child = SCLP_EVENT_GET_CLASS((SCLPEvent *) qdev); 82 mask |= child->get_receive_mask(); 83 } 84 return mask; 85 } 86 87 static uint16_t write_event_length_check(SCCB *sccb) 88 { 89 int slen; 90 unsigned elen = 0; 91 EventBufferHeader *event; 92 WriteEventData *wed = (WriteEventData *) sccb; 93 94 event = (EventBufferHeader *) &wed->ebh; 95 for (slen = sccb_data_len(sccb); slen > 0; slen -= elen) { 96 elen = be16_to_cpu(event->length); 97 if (elen < sizeof(*event) || elen > slen) { 98 return SCLP_RC_EVENT_BUFFER_SYNTAX_ERROR; 99 } 100 event = (void *) event + elen; 101 } 102 if (slen) { 103 return SCLP_RC_INCONSISTENT_LENGTHS; 104 } 105 return SCLP_RC_NORMAL_COMPLETION; 106 } 107 108 static uint16_t handle_write_event_buf(SCLPEventFacility *ef, 109 EventBufferHeader *event_buf, SCCB *sccb) 110 { 111 uint16_t rc; 112 BusChild *kid; 113 SCLPEvent *event; 114 SCLPEventClass *ec; 115 116 rc = SCLP_RC_INVALID_FUNCTION; 117 118 QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) { 119 DeviceState *qdev = kid->child; 120 event = (SCLPEvent *) qdev; 121 ec = SCLP_EVENT_GET_CLASS(event); 122 123 if (ec->write_event_data && 124 ec->can_handle_event(event_buf->type)) { 125 rc = ec->write_event_data(event, event_buf); 126 break; 127 } 128 } 129 return rc; 130 } 131 132 static uint16_t handle_sccb_write_events(SCLPEventFacility *ef, SCCB *sccb) 133 { 134 uint16_t rc; 135 int slen; 136 unsigned elen = 0; 137 EventBufferHeader *event_buf; 138 WriteEventData *wed = (WriteEventData *) sccb; 139 140 event_buf = &wed->ebh; 141 rc = SCLP_RC_NORMAL_COMPLETION; 142 143 /* loop over all contained event buffers */ 144 for (slen = sccb_data_len(sccb); slen > 0; slen -= elen) { 145 elen = be16_to_cpu(event_buf->length); 146 147 /* in case of a previous error mark all trailing buffers 148 * as not accepted */ 149 if (rc != SCLP_RC_NORMAL_COMPLETION) { 150 event_buf->flags &= ~(SCLP_EVENT_BUFFER_ACCEPTED); 151 } else { 152 rc = handle_write_event_buf(ef, event_buf, sccb); 153 } 154 event_buf = (void *) event_buf + elen; 155 } 156 return rc; 157 } 158 159 static void write_event_data(SCLPEventFacility *ef, SCCB *sccb) 160 { 161 if (sccb->h.function_code != SCLP_FC_NORMAL_WRITE) { 162 sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION); 163 goto out; 164 } 165 if (be16_to_cpu(sccb->h.length) < 8) { 166 sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH); 167 goto out; 168 } 169 /* first do a sanity check of the write events */ 170 sccb->h.response_code = cpu_to_be16(write_event_length_check(sccb)); 171 172 /* if no early error, then execute */ 173 if (sccb->h.response_code == be16_to_cpu(SCLP_RC_NORMAL_COMPLETION)) { 174 sccb->h.response_code = 175 cpu_to_be16(handle_sccb_write_events(ef, sccb)); 176 } 177 178 out: 179 return; 180 } 181 182 static uint16_t handle_sccb_read_events(SCLPEventFacility *ef, SCCB *sccb, 183 unsigned int mask) 184 { 185 uint16_t rc; 186 int slen; 187 unsigned elen; 188 BusChild *kid; 189 SCLPEvent *event; 190 SCLPEventClass *ec; 191 EventBufferHeader *event_buf; 192 ReadEventData *red = (ReadEventData *) sccb; 193 194 event_buf = &red->ebh; 195 event_buf->length = 0; 196 slen = sizeof(sccb->data); 197 198 rc = SCLP_RC_NO_EVENT_BUFFERS_STORED; 199 200 QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) { 201 DeviceState *qdev = kid->child; 202 event = (SCLPEvent *) qdev; 203 ec = SCLP_EVENT_GET_CLASS(event); 204 205 if (mask & ec->get_send_mask()) { 206 if (ec->read_event_data(event, event_buf, &slen)) { 207 elen = be16_to_cpu(event_buf->length); 208 event_buf = (EventBufferHeader *) ((char *)event_buf + elen); 209 rc = SCLP_RC_NORMAL_COMPLETION; 210 } 211 } 212 } 213 214 if (sccb->h.control_mask[2] & SCLP_VARIABLE_LENGTH_RESPONSE) { 215 /* architecture suggests to reset variable-length-response bit */ 216 sccb->h.control_mask[2] &= ~SCLP_VARIABLE_LENGTH_RESPONSE; 217 /* with a new length value */ 218 sccb->h.length = cpu_to_be16(SCCB_SIZE - slen); 219 } 220 return rc; 221 } 222 223 static void read_event_data(SCLPEventFacility *ef, SCCB *sccb) 224 { 225 unsigned int sclp_active_selection_mask; 226 unsigned int sclp_cp_receive_mask; 227 228 ReadEventData *red = (ReadEventData *) sccb; 229 230 if (be16_to_cpu(sccb->h.length) != SCCB_SIZE) { 231 sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH); 232 goto out; 233 } 234 235 sclp_cp_receive_mask = ef->receive_mask; 236 237 /* get active selection mask */ 238 switch (sccb->h.function_code) { 239 case SCLP_UNCONDITIONAL_READ: 240 sclp_active_selection_mask = sclp_cp_receive_mask; 241 break; 242 case SCLP_SELECTIVE_READ: 243 if (!(sclp_cp_receive_mask & be32_to_cpu(red->mask))) { 244 sccb->h.response_code = 245 cpu_to_be16(SCLP_RC_INVALID_SELECTION_MASK); 246 goto out; 247 } 248 sclp_active_selection_mask = be32_to_cpu(red->mask); 249 break; 250 default: 251 sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION); 252 goto out; 253 } 254 sccb->h.response_code = cpu_to_be16( 255 handle_sccb_read_events(ef, sccb, sclp_active_selection_mask)); 256 257 out: 258 return; 259 } 260 261 static void write_event_mask(SCLPEventFacility *ef, SCCB *sccb) 262 { 263 WriteEventMask *we_mask = (WriteEventMask *) sccb; 264 265 /* Attention: We assume that Linux uses 4-byte masks, what it actually 266 does. Architecture allows for masks of variable size, though */ 267 if (be16_to_cpu(we_mask->mask_length) != 4) { 268 sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_MASK_LENGTH); 269 goto out; 270 } 271 272 /* keep track of the guest's capability masks */ 273 ef->receive_mask = be32_to_cpu(we_mask->cp_receive_mask); 274 275 /* return the SCLP's capability masks to the guest */ 276 we_mask->send_mask = cpu_to_be32(get_host_send_mask(ef)); 277 we_mask->receive_mask = cpu_to_be32(get_host_receive_mask(ef)); 278 279 sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION); 280 281 out: 282 return; 283 } 284 285 /* qemu object creation and initialization functions */ 286 287 #define TYPE_SCLP_EVENTS_BUS "s390-sclp-events-bus" 288 289 static void sclp_events_bus_class_init(ObjectClass *klass, void *data) 290 { 291 } 292 293 static const TypeInfo sclp_events_bus_info = { 294 .name = TYPE_SCLP_EVENTS_BUS, 295 .parent = TYPE_BUS, 296 .class_init = sclp_events_bus_class_init, 297 }; 298 299 static void command_handler(SCLPEventFacility *ef, SCCB *sccb, uint64_t code) 300 { 301 switch (code & SCLP_CMD_CODE_MASK) { 302 case SCLP_CMD_READ_EVENT_DATA: 303 read_event_data(ef, sccb); 304 break; 305 case SCLP_CMD_WRITE_EVENT_DATA: 306 write_event_data(ef, sccb); 307 break; 308 case SCLP_CMD_WRITE_EVENT_MASK: 309 write_event_mask(ef, sccb); 310 break; 311 default: 312 sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND); 313 break; 314 } 315 } 316 317 static const VMStateDescription vmstate_event_facility = { 318 .name = "vmstate-event-facility", 319 .version_id = 0, 320 .minimum_version_id = 0, 321 .fields = (VMStateField[]) { 322 VMSTATE_UINT32(receive_mask, SCLPEventFacility), 323 VMSTATE_END_OF_LIST() 324 } 325 }; 326 327 static int init_event_facility(SCLPEventFacility *event_facility) 328 { 329 DeviceState *sdev = DEVICE(event_facility); 330 DeviceState *quiesce; 331 332 /* Spawn a new bus for SCLP events */ 333 qbus_create_inplace(&event_facility->sbus, sizeof(event_facility->sbus), 334 TYPE_SCLP_EVENTS_BUS, sdev, NULL); 335 336 quiesce = qdev_create(&event_facility->sbus.qbus, "sclpquiesce"); 337 if (!quiesce) { 338 return -1; 339 } 340 qdev_init_nofail(quiesce); 341 342 object_initialize(&cpu_hotplug, sizeof(cpu_hotplug), TYPE_SCLP_CPU_HOTPLUG); 343 qdev_set_parent_bus(DEVICE(&cpu_hotplug), BUS(&event_facility->sbus)); 344 object_property_set_bool(OBJECT(&cpu_hotplug), true, "realized", NULL); 345 346 return 0; 347 } 348 349 static void reset_event_facility(DeviceState *dev) 350 { 351 SCLPEventFacility *sdev = EVENT_FACILITY(dev); 352 353 sdev->receive_mask = 0; 354 } 355 356 static void init_event_facility_class(ObjectClass *klass, void *data) 357 { 358 SysBusDeviceClass *sbdc = SYS_BUS_DEVICE_CLASS(klass); 359 DeviceClass *dc = DEVICE_CLASS(sbdc); 360 SCLPEventFacilityClass *k = EVENT_FACILITY_CLASS(dc); 361 362 dc->reset = reset_event_facility; 363 dc->vmsd = &vmstate_event_facility; 364 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 365 k->init = init_event_facility; 366 k->command_handler = command_handler; 367 k->event_pending = event_pending; 368 } 369 370 static const TypeInfo sclp_event_facility_info = { 371 .name = TYPE_SCLP_EVENT_FACILITY, 372 .parent = TYPE_SYS_BUS_DEVICE, 373 .instance_size = sizeof(SCLPEventFacility), 374 .class_init = init_event_facility_class, 375 .class_size = sizeof(SCLPEventFacilityClass), 376 }; 377 378 static void event_realize(DeviceState *qdev, Error **errp) 379 { 380 SCLPEvent *event = SCLP_EVENT(qdev); 381 SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event); 382 383 if (child->init) { 384 int rc = child->init(event); 385 if (rc < 0) { 386 error_setg(errp, "SCLP event initialization failed."); 387 return; 388 } 389 } 390 } 391 392 static void event_unrealize(DeviceState *qdev, Error **errp) 393 { 394 SCLPEvent *event = SCLP_EVENT(qdev); 395 SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event); 396 if (child->exit) { 397 int rc = child->exit(event); 398 if (rc < 0) { 399 error_setg(errp, "SCLP event exit failed."); 400 return; 401 } 402 } 403 } 404 405 static void event_class_init(ObjectClass *klass, void *data) 406 { 407 DeviceClass *dc = DEVICE_CLASS(klass); 408 409 dc->bus_type = TYPE_SCLP_EVENTS_BUS; 410 dc->realize = event_realize; 411 dc->unrealize = event_unrealize; 412 } 413 414 static const TypeInfo sclp_event_type_info = { 415 .name = TYPE_SCLP_EVENT, 416 .parent = TYPE_DEVICE, 417 .instance_size = sizeof(SCLPEvent), 418 .class_init = event_class_init, 419 .class_size = sizeof(SCLPEventClass), 420 .abstract = true, 421 }; 422 423 static void register_types(void) 424 { 425 type_register_static(&sclp_events_bus_info); 426 type_register_static(&sclp_event_facility_info); 427 type_register_static(&sclp_event_type_info); 428 } 429 430 type_init(register_types) 431