[thirdparty/qemu.git] / hw / s390x / event-facility.c

/*
 * SCLP
 *    Event Facility
 *       handles SCLP event types
 *          - Signal Quiesce - system power down
 *          - ASCII Console Data - VT220 read and write
 *
 * Copyright IBM, Corp. 2012
 *
 * Authors:
 *  Heinz Graalfs <graalfs@de.ibm.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or (at your
 * option) any later version.  See the COPYING file in the top-level directory.
 *
 */

#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu/module.h"

#include "hw/s390x/sclp.h"
#include "migration/vmstate.h"
#include "hw/s390x/event-facility.h"

typedef struct SCLPEventsBus {
    BusState qbus;
} SCLPEventsBus;

/* we need to save 32 bit chunks for compatibility */
#if HOST_BIG_ENDIAN
#define RECV_MASK_LOWER 1
#define RECV_MASK_UPPER 0
#else /* little endian host */
#define RECV_MASK_LOWER 0
#define RECV_MASK_UPPER 1
#endif

struct SCLPEventFacility {
    SysBusDevice parent_obj;
    SCLPEventsBus sbus;
    SCLPEvent quiesce, cpu_hotplug;
    /* guest's receive mask */
    union {
        uint32_t receive_mask_pieces[2];
        sccb_mask_t receive_mask;
    };
    /*
     * when false, we keep the same broken, backwards compatible behaviour as
     * before, allowing only masks of size exactly 4; when true, we implement
     * the architecture correctly, allowing all valid mask sizes. Needed for
     * migration toward older versions.
     */
    bool allow_all_mask_sizes;
    /* length of the receive mask */
    uint16_t mask_length;
};

/* return true if any child has event pending set */
static bool event_pending(SCLPEventFacility *ef)
{
    BusChild *kid;
    SCLPEvent *event;
    SCLPEventClass *event_class;

    QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
        event = SCLP_EVENT(kid->child);
        event_class = SCLP_EVENT_GET_CLASS(event);
        if (event->event_pending &&
            event_class->get_send_mask() & ef->receive_mask) {
            return true;
        }
    }
    return false;
}

static sccb_mask_t get_host_send_mask(SCLPEventFacility *ef)
{
    sccb_mask_t mask;
    BusChild *kid;
    SCLPEventClass *child;

    mask = 0;

    QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
        DeviceState *qdev = kid->child;
        child = SCLP_EVENT_GET_CLASS((SCLPEvent *) qdev);
        mask |= child->get_send_mask();
    }
    return mask;
}

static sccb_mask_t get_host_receive_mask(SCLPEventFacility *ef)
{
    sccb_mask_t mask;
    BusChild *kid;
    SCLPEventClass *child;

    mask = 0;

    QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
        DeviceState *qdev = kid->child;
        child = SCLP_EVENT_GET_CLASS((SCLPEvent *) qdev);
        mask |= child->get_receive_mask();
    }
    return mask;
}

static uint16_t write_event_length_check(SCCB *sccb)
{
    int slen;
    unsigned elen = 0;
    EventBufferHeader *event;
    WriteEventData *wed = (WriteEventData *) sccb;

    event = (EventBufferHeader *) &wed->ebh;
    for (slen = sccb_data_len(sccb); slen > 0; slen -= elen) {
        elen = be16_to_cpu(event->length);
        if (elen < sizeof(*event) || elen > slen) {
            return SCLP_RC_EVENT_BUFFER_SYNTAX_ERROR;
        }
        event = (void *) event + elen;
    }
    if (slen) {
        return SCLP_RC_INCONSISTENT_LENGTHS;
    }
    return SCLP_RC_NORMAL_COMPLETION;
}

static uint16_t handle_write_event_buf(SCLPEventFacility *ef,
                                       EventBufferHeader *event_buf, SCCB *sccb)
{
    uint16_t rc;
    BusChild *kid;
    SCLPEvent *event;
    SCLPEventClass *ec;

    rc = SCLP_RC_INVALID_FUNCTION;

    QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
        DeviceState *qdev = kid->child;
        event = (SCLPEvent *) qdev;
        ec = SCLP_EVENT_GET_CLASS(event);

        if (ec->write_event_data &&
            ec->can_handle_event(event_buf->type)) {
            rc = ec->write_event_data(event, event_buf);
            break;
        }
    }
    return rc;
}

static uint16_t handle_sccb_write_events(SCLPEventFacility *ef, SCCB *sccb)
{
    uint16_t rc;
    int slen;
    unsigned elen = 0;
    EventBufferHeader *event_buf;
    WriteEventData *wed = (WriteEventData *) sccb;

    event_buf = &wed->ebh;
    rc = SCLP_RC_NORMAL_COMPLETION;

    /* loop over all contained event buffers */
    for (slen = sccb_data_len(sccb); slen > 0; slen -= elen) {
        elen = be16_to_cpu(event_buf->length);

        /* in case of a previous error mark all trailing buffers
         * as not accepted */
        if (rc != SCLP_RC_NORMAL_COMPLETION) {
            event_buf->flags &= ~(SCLP_EVENT_BUFFER_ACCEPTED);
        } else {
            rc = handle_write_event_buf(ef, event_buf, sccb);
        }
        event_buf = (void *) event_buf + elen;
    }
    return rc;
}

static void write_event_data(SCLPEventFacility *ef, SCCB *sccb)
{
    if (sccb->h.function_code != SCLP_FC_NORMAL_WRITE) {
        sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION);
        return;
    }
    if (be16_to_cpu(sccb->h.length) < 8) {
        sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
        return;
    }
    /* first do a sanity check of the write events */
    sccb->h.response_code = cpu_to_be16(write_event_length_check(sccb));

    /* if no early error, then execute */
    if (sccb->h.response_code == be16_to_cpu(SCLP_RC_NORMAL_COMPLETION)) {
        sccb->h.response_code =
                cpu_to_be16(handle_sccb_write_events(ef, sccb));
    }
}

static uint16_t handle_sccb_read_events(SCLPEventFacility *ef, SCCB *sccb,
                                        sccb_mask_t mask)
{
    uint16_t rc;
    int slen;
    unsigned elen;
    BusChild *kid;
    SCLPEvent *event;
    SCLPEventClass *ec;
    EventBufferHeader *event_buf;
    ReadEventData *red = (ReadEventData *) sccb;

    event_buf = &red->ebh;
    event_buf->length = 0;
    slen = sccb_data_len(sccb);

    rc = SCLP_RC_NO_EVENT_BUFFERS_STORED;

    QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
        DeviceState *qdev = kid->child;
        event = (SCLPEvent *) qdev;
        ec = SCLP_EVENT_GET_CLASS(event);

        if (mask & ec->get_send_mask()) {
            if (ec->read_event_data(event, event_buf, &slen)) {
                elen = be16_to_cpu(event_buf->length);
                event_buf = (EventBufferHeader *) ((char *)event_buf + elen);
                rc = SCLP_RC_NORMAL_COMPLETION;
            }
        }
    }

    if (sccb->h.control_mask[2] & SCLP_VARIABLE_LENGTH_RESPONSE) {
        /* architecture suggests to reset variable-length-response bit */
        sccb->h.control_mask[2] &= ~SCLP_VARIABLE_LENGTH_RESPONSE;
        /* with a new length value */
        sccb->h.length = cpu_to_be16(SCCB_SIZE - slen);
    }
    return rc;
}

/* copy up to src_len bytes and fill the rest of dst with zeroes */
static void copy_mask(uint8_t *dst, uint8_t *src, uint16_t dst_len,
                      uint16_t src_len)
{
    int i;

    for (i = 0; i < dst_len; i++) {
        dst[i] = i < src_len ? src[i] : 0;
    }
}

static void read_event_data(SCLPEventFacility *ef, SCCB *sccb)
{
    sccb_mask_t sclp_active_selection_mask;
    sccb_mask_t sclp_cp_receive_mask;

    ReadEventData *red = (ReadEventData *) sccb;

    if (be16_to_cpu(sccb->h.length) != SCCB_SIZE) {
        sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
        return;
    }

    switch (sccb->h.function_code) {
    case SCLP_UNCONDITIONAL_READ:
        sccb->h.response_code = cpu_to_be16(
            handle_sccb_read_events(ef, sccb, ef->receive_mask));
        break;
    case SCLP_SELECTIVE_READ:
        /* get active selection mask */
        sclp_cp_receive_mask = ef->receive_mask;

        copy_mask((uint8_t *)&sclp_active_selection_mask, (uint8_t *)&red->mask,
                  sizeof(sclp_active_selection_mask), ef->mask_length);
        sclp_active_selection_mask = be64_to_cpu(sclp_active_selection_mask);
        if (!sclp_cp_receive_mask ||
            (sclp_active_selection_mask & ~sclp_cp_receive_mask)) {
            sccb->h.response_code =
                    cpu_to_be16(SCLP_RC_INVALID_SELECTION_MASK);
        } else {
            sccb->h.response_code = cpu_to_be16(
                handle_sccb_read_events(ef, sccb, sclp_active_selection_mask));
        }
        break;
    default:
        sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION);
    }
}

static void write_event_mask(SCLPEventFacility *ef, SCCB *sccb)
{
    WriteEventMask *we_mask = (WriteEventMask *) sccb;
    uint16_t mask_length = be16_to_cpu(we_mask->mask_length);
    sccb_mask_t tmp_mask;

    if (!mask_length || (mask_length > SCLP_EVENT_MASK_LEN_MAX) ||
        ((mask_length != 4) && !ef->allow_all_mask_sizes)) {
        sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_MASK_LENGTH);
        return;
    }

    /*
     * Note: We currently only support masks up to 8 byte length;
     *       the remainder is filled up with zeroes. Older Linux
     *       kernels use a 4 byte mask length, newer ones can use both
     *       8 or 4 depending on what is available on the host.
     */

    /* keep track of the guest's capability masks */
    copy_mask((uint8_t *)&tmp_mask, WEM_CP_RECEIVE_MASK(we_mask, mask_length),
              sizeof(tmp_mask), mask_length);
    ef->receive_mask = be64_to_cpu(tmp_mask);

    /* return the SCLP's capability masks to the guest */
    tmp_mask = cpu_to_be64(get_host_receive_mask(ef));
    copy_mask(WEM_RECEIVE_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
              mask_length, sizeof(tmp_mask));
    tmp_mask = cpu_to_be64(get_host_send_mask(ef));
    copy_mask(WEM_SEND_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
              mask_length, sizeof(tmp_mask));

    sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
    ef->mask_length = mask_length;
}

/* qemu object creation and initialization functions */

#define TYPE_SCLP_EVENTS_BUS "s390-sclp-events-bus"

static const TypeInfo sclp_events_bus_info = {
    .name = TYPE_SCLP_EVENTS_BUS,
    .parent = TYPE_BUS,
};

static void command_handler(SCLPEventFacility *ef, SCCB *sccb, uint64_t code)
{
    switch (code & SCLP_CMD_CODE_MASK) {
    case SCLP_CMD_READ_EVENT_DATA:
        read_event_data(ef, sccb);
        break;
    case SCLP_CMD_WRITE_EVENT_DATA:
        write_event_data(ef, sccb);
        break;
    case SCLP_CMD_WRITE_EVENT_MASK:
        write_event_mask(ef, sccb);
        break;
    }
}

static bool vmstate_event_facility_mask64_needed(void *opaque)
{
    SCLPEventFacility *ef = opaque;

    return (ef->receive_mask & 0xFFFFFFFF) != 0;
}

static bool vmstate_event_facility_mask_length_needed(void *opaque)
{
    SCLPEventFacility *ef = opaque;

    return ef->allow_all_mask_sizes;
}

static const VMStateDescription vmstate_event_facility_mask64 = {
    .name = "vmstate-event-facility/mask64",
    .version_id = 0,
    .minimum_version_id = 0,
    .needed = vmstate_event_facility_mask64_needed,
    .fields = (const VMStateField[]) {
        VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_LOWER], SCLPEventFacility),
        VMSTATE_END_OF_LIST()
     }
};

static const VMStateDescription vmstate_event_facility_mask_length = {
    .name = "vmstate-event-facility/mask_length",
    .version_id = 0,
    .minimum_version_id = 0,
    .needed = vmstate_event_facility_mask_length_needed,
    .fields = (const VMStateField[]) {
        VMSTATE_UINT16(mask_length, SCLPEventFacility),
        VMSTATE_END_OF_LIST()
     }
};

static const VMStateDescription vmstate_event_facility = {
    .name = "vmstate-event-facility",
    .version_id = 0,
    .minimum_version_id = 0,
    .fields = (const VMStateField[]) {
        VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_UPPER], SCLPEventFacility),
        VMSTATE_END_OF_LIST()
     },
    .subsections = (const VMStateDescription * const []) {
        &vmstate_event_facility_mask64,
        &vmstate_event_facility_mask_length,
        NULL
     }
};

static void sclp_event_set_allow_all_mask_sizes(Object *obj, bool value,
                                                       Error **errp)
{
    SCLPEventFacility *ef = (SCLPEventFacility *)obj;

    ef->allow_all_mask_sizes = value;
}

static bool sclp_event_get_allow_all_mask_sizes(Object *obj, Error **errp)
{
    SCLPEventFacility *ef = (SCLPEventFacility *)obj;

    return ef->allow_all_mask_sizes;
}

static void init_event_facility(Object *obj)
{
    SCLPEventFacility *event_facility = EVENT_FACILITY(obj);
    DeviceState *sdev = DEVICE(obj);

    event_facility->mask_length = 4;
    event_facility->allow_all_mask_sizes = true;
    object_property_add_bool(obj, "allow_all_mask_sizes",
                             sclp_event_get_allow_all_mask_sizes,
                             sclp_event_set_allow_all_mask_sizes);

    /* Spawn a new bus for SCLP events */
    qbus_init(&event_facility->sbus, sizeof(event_facility->sbus),
              TYPE_SCLP_EVENTS_BUS, sdev, NULL);

    object_initialize_child(obj, TYPE_SCLP_QUIESCE,
                            &event_facility->quiesce,
                            TYPE_SCLP_QUIESCE);

    object_initialize_child(obj, TYPE_SCLP_CPU_HOTPLUG,
                            &event_facility->cpu_hotplug,
                            TYPE_SCLP_CPU_HOTPLUG);
}

static void realize_event_facility(DeviceState *dev, Error **errp)
{
    SCLPEventFacility *event_facility = EVENT_FACILITY(dev);

    if (!qdev_realize(DEVICE(&event_facility->quiesce),
                      BUS(&event_facility->sbus), errp)) {
        return;
    }
    if (!qdev_realize(DEVICE(&event_facility->cpu_hotplug),
                      BUS(&event_facility->sbus), errp)) {
        qdev_unrealize(DEVICE(&event_facility->quiesce));
        return;
    }
}

static void reset_event_facility(DeviceState *dev)
{
    SCLPEventFacility *sdev = EVENT_FACILITY(dev);

    sdev->receive_mask = 0;
}

static void init_event_facility_class(ObjectClass *klass, void *data)
{
    SysBusDeviceClass *sbdc = SYS_BUS_DEVICE_CLASS(klass);
    DeviceClass *dc = DEVICE_CLASS(sbdc);
    SCLPEventFacilityClass *k = EVENT_FACILITY_CLASS(dc);

    dc->realize = realize_event_facility;
    dc->reset = reset_event_facility;
    dc->vmsd = &vmstate_event_facility;
    set_bit(DEVICE_CATEGORY_MISC, dc->categories);
    k->command_handler = command_handler;
    k->event_pending = event_pending;
}

static const TypeInfo sclp_event_facility_info = {
    .name          = TYPE_SCLP_EVENT_FACILITY,
    .parent        = TYPE_SYS_BUS_DEVICE,
    .instance_init = init_event_facility,
    .instance_size = sizeof(SCLPEventFacility),
    .class_init    = init_event_facility_class,
    .class_size    = sizeof(SCLPEventFacilityClass),
};

static void event_realize(DeviceState *qdev, Error **errp)
{
    SCLPEvent *event = SCLP_EVENT(qdev);
    SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event);

    if (child->init) {
        int rc = child->init(event);
        if (rc < 0) {
            error_setg(errp, "SCLP event initialization failed.");
            return;
        }
    }
}

static void event_class_init(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);

    dc->bus_type = TYPE_SCLP_EVENTS_BUS;
    dc->realize = event_realize;
}

static const TypeInfo sclp_event_type_info = {
    .name = TYPE_SCLP_EVENT,
    .parent = TYPE_DEVICE,
    .instance_size = sizeof(SCLPEvent),
    .class_init = event_class_init,
    .class_size = sizeof(SCLPEventClass),
    .abstract = true,
};

static void register_types(void)
{
    type_register_static(&sclp_events_bus_info);
    type_register_static(&sclp_event_facility_info);
    type_register_static(&sclp_event_type_info);
}

type_init(register_types)

BusState *sclp_get_event_facility_bus(SCLPEventFacility *ef)
{
    return BUS(&ef->sbus);
}
Commit	Line	Data
559a17a1 HG	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
9615495a	18	#include "qemu/osdep.h"
da34e65c	19	#include "qapi/error.h"
0b8fa32f	20	#include "qemu/module.h"
559a17a1	21
83c9f4ca	22	#include "hw/s390x/sclp.h"
d6454270	23	#include "migration/vmstate.h"
83c9f4ca	24	#include "hw/s390x/event-facility.h"
559a17a1	25
65e526c2	26	typedef struct SCLPEventsBus {
559a17a1	27	BusState qbus;
65e526c2	28	} SCLPEventsBus;
559a17a1	29
98e43b71	30	/* we need to save 32 bit chunks for compatibility */
e03b5686	31	#if HOST_BIG_ENDIAN
98e43b71 CI	32	#define RECV_MASK_LOWER 1
	33	#define RECV_MASK_UPPER 0
	34	#else /* little endian host */
	35	#define RECV_MASK_LOWER 0
	36	#define RECV_MASK_UPPER 1
	37	#endif
	38
559a17a1	39	struct SCLPEventFacility {
477a72a1	40	SysBusDevice parent_obj;
65e526c2	41	SCLPEventsBus sbus;
1afec9e8	42	SCLPEvent quiesce, cpu_hotplug;
1ffed98f	43	/* guest's receive mask */
98e43b71 CI	44	union {
	45	uint32_t receive_mask_pieces[2];
	46	sccb_mask_t receive_mask;
	47	};
bc61c8c6 CI	48	/*
	49	* when false, we keep the same broken, backwards compatible behaviour as
	50	* before, allowing only masks of size exactly 4; when true, we implement
	51	* the architecture correctly, allowing all valid mask sizes. Needed for
	52	* migration toward older versions.
	53	*/
	54	bool allow_all_mask_sizes;
	55	/* length of the receive mask */
	56	uint16_t mask_length;
559a17a1 HG	57	};
	58
	59	/* return true if any child has event pending set */
	60	static bool event_pending(SCLPEventFacility *ef)
	61	{
	62	BusChild *kid;
	63	SCLPEvent *event;
	64	SCLPEventClass *event_class;
	65
	66	QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) {
b1d1d468	67	event = SCLP_EVENT(kid->child);
559a17a1 HG	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
1ffed98f	77	static sccb_mask_t get_host_send_mask(SCLPEventFacility *ef)
559a17a1	78	{
1ffed98f	79	sccb_mask_t mask;
559a17a1 HG	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
1ffed98f	93	static sccb_mask_t get_host_receive_mask(SCLPEventFacility *ef)
559a17a1	94	{
1ffed98f	95	sccb_mask_t mask;
559a17a1 HG	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
	109	static 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
	130	static 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
773de5c7 CH	138	rc = SCLP_RC_INVALID_FUNCTION;
773de5c7 CH	139
559a17a1 HG	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
559a17a1	145	if (ec->write_event_data &&
c3d9f24a	146	ec->can_handle_event(event_buf->type)) {
559a17a1 HG	147	rc = ec->write_event_data(event, event_buf);
	148	break;
	149	}
	150	}
	151	return rc;
	152	}
	153
	154	static 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	/* loop over all contained event buffers */
	166	for (slen = sccb_data_len(sccb); slen > 0; slen -= elen) {
	167	elen = be16_to_cpu(event_buf->length);
	168
	169	/* in case of a previous error mark all trailing buffers
	170	* as not accepted */
	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
	181	static 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);
9208270b	185	return;
559a17a1 HG	186	}
	187	if (be16_to_cpu(sccb->h.length) < 8) {
	188	sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
9208270b	189	return;
559a17a1 HG	190	}
	191	/* first do a sanity check of the write events */
	192	sccb->h.response_code = cpu_to_be16(write_event_length_check(sccb));
	193
	194	/* if no early error, then execute */
	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	}
559a17a1 HG	199	}
	200
	201	static uint16_t handle_sccb_read_events(SCLPEventFacility ef, SCCB sccb,
1ffed98f	202	sccb_mask_t mask)
559a17a1 HG	203	{
	204	uint16_t rc;
	205	int slen;
a0c8699b	206	unsigned elen;
559a17a1 HG	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;
c1db53a5	215	slen = sccb_data_len(sccb);
559a17a1 HG	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)) {
a0c8699b RH	226	elen = be16_to_cpu(event_buf->length);
a0c8699b RH	227	event_buf = (EventBufferHeader ) ((char )event_buf + elen);
559a17a1 HG	228	rc = SCLP_RC_NORMAL_COMPLETION;
	229	}
	230	}
559a17a1 HG	231	}
	232
	233	if (sccb->h.control_mask[2] & SCLP_VARIABLE_LENGTH_RESPONSE) {
	234	/* architecture suggests to reset variable-length-response bit */
	235	sccb->h.control_mask[2] &= ~SCLP_VARIABLE_LENGTH_RESPONSE;
	236	/* with a new length value */
	237	sccb->h.length = cpu_to_be16(SCCB_SIZE - slen);
	238	}
	239	return rc;
	240	}
	241
bc61c8c6 CI	242	/* copy up to src_len bytes and fill the rest of dst with zeroes */
	243	static 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
559a17a1 HG	253	static void read_event_data(SCLPEventFacility ef, SCCB sccb)
559a17a1 HG	254	{
1ffed98f CI	255	sccb_mask_t sclp_active_selection_mask;
1ffed98f CI	256	sccb_mask_t sclp_cp_receive_mask;
559a17a1 HG	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);
9208270b	262	return;
559a17a1 HG	263	}
559a17a1 HG	264
559a17a1 HG	265	switch (sccb->h.function_code) {
559a17a1 HG	266	case SCLP_UNCONDITIONAL_READ:
9208270b DHB	267	sccb->h.response_code = cpu_to_be16(
9208270b DHB	268	handle_sccb_read_events(ef, sccb, ef->receive_mask));
559a17a1 HG	269	break;
559a17a1 HG	270	case SCLP_SELECTIVE_READ:
9208270b DHB	271	/* get active selection mask */
	272	sclp_cp_receive_mask = ef->receive_mask;
	273
bc61c8c6 CI	274	copy_mask((uint8_t )&sclp_active_selection_mask, (uint8_t )&red->mask,
bc61c8c6 CI	275	sizeof(sclp_active_selection_mask), ef->mask_length);
98e43b71	276	sclp_active_selection_mask = be64_to_cpu(sclp_active_selection_mask);
3335dddd CH	277	if (!sclp_cp_receive_mask \|\|
3335dddd CH	278	(sclp_active_selection_mask & ~sclp_cp_receive_mask)) {
559a17a1 HG	279	sccb->h.response_code =
559a17a1 HG	280	cpu_to_be16(SCLP_RC_INVALID_SELECTION_MASK);
9208270b DHB	281	} else {
	282	sccb->h.response_code = cpu_to_be16(
	283	handle_sccb_read_events(ef, sccb, sclp_active_selection_mask));
559a17a1	284	}
559a17a1 HG	285	break;
	286	default:
	287	sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION);
559a17a1	288	}
559a17a1 HG	289	}
	290
	291	static void write_event_mask(SCLPEventFacility ef, SCCB sccb)
	292	{
	293	WriteEventMask we_mask = (WriteEventMask ) sccb;
67915de9	294	uint16_t mask_length = be16_to_cpu(we_mask->mask_length);
1ffed98f	295	sccb_mask_t tmp_mask;
559a17a1	296
bc61c8c6 CI	297	if (!mask_length \|\| (mask_length > SCLP_EVENT_MASK_LEN_MAX) \|\|
bc61c8c6 CI	298	((mask_length != 4) && !ef->allow_all_mask_sizes)) {
559a17a1	299	sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_MASK_LENGTH);
9208270b	300	return;
559a17a1 HG	301	}
559a17a1 HG	302
67915de9	303	/*
98e43b71 CI	304	* Note: We currently only support masks up to 8 byte length;
	305	* the remainder is filled up with zeroes. Older Linux
	306	* kernels use a 4 byte mask length, newer ones can use both
	307	* 8 or 4 depending on what is available on the host.
67915de9 CH	308	*/
67915de9 CH	309
559a17a1	310	/* keep track of the guest's capability masks */
67915de9 CH	311	copy_mask((uint8_t *)&tmp_mask, WEM_CP_RECEIVE_MASK(we_mask, mask_length),
67915de9 CH	312	sizeof(tmp_mask), mask_length);
98e43b71	313	ef->receive_mask = be64_to_cpu(tmp_mask);
559a17a1 HG	314
559a17a1 HG	315	/* return the SCLP's capability masks to the guest */
98e43b71	316	tmp_mask = cpu_to_be64(get_host_receive_mask(ef));
67915de9 CH	317	copy_mask(WEM_RECEIVE_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
67915de9 CH	318	mask_length, sizeof(tmp_mask));
98e43b71	319	tmp_mask = cpu_to_be64(get_host_send_mask(ef));
67915de9 CH	320	copy_mask(WEM_SEND_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
67915de9 CH	321	mask_length, sizeof(tmp_mask));
559a17a1 HG	322
559a17a1 HG	323	sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
bc61c8c6	324	ef->mask_length = mask_length;
559a17a1 HG	325	}
	326
	327	/* qemu object creation and initialization functions */
	328
	329	#define TYPE_SCLP_EVENTS_BUS "s390-sclp-events-bus"
	330
65e526c2	331	static const TypeInfo sclp_events_bus_info = {
559a17a1 HG	332	.name = TYPE_SCLP_EVENTS_BUS,
559a17a1 HG	333	.parent = TYPE_BUS,
559a17a1 HG	334	};
	335
	336	static void command_handler(SCLPEventFacility ef, SCCB sccb, uint64_t code)
	337	{
9da45bb2	338	switch (code & SCLP_CMD_CODE_MASK) {
559a17a1 HG	339	case SCLP_CMD_READ_EVENT_DATA:
	340	read_event_data(ef, sccb);
	341	break;
	342	case SCLP_CMD_WRITE_EVENT_DATA:
	343	write_event_data(ef, sccb);
	344	break;
	345	case SCLP_CMD_WRITE_EVENT_MASK:
	346	write_event_mask(ef, sccb);
	347	break;
559a17a1 HG	348	}
	349	}
	350
98e43b71 CI	351	static bool vmstate_event_facility_mask64_needed(void *opaque)
	352	{
	353	SCLPEventFacility *ef = opaque;
	354
	355	return (ef->receive_mask & 0xFFFFFFFF) != 0;
	356	}
	357
bc61c8c6 CI	358	static bool vmstate_event_facility_mask_length_needed(void *opaque)
	359	{
	360	SCLPEventFacility *ef = opaque;
	361
	362	return ef->allow_all_mask_sizes;
	363	}
	364
98e43b71 CI	365	static const VMStateDescription vmstate_event_facility_mask64 = {
	366	.name = "vmstate-event-facility/mask64",
	367	.version_id = 0,
	368	.minimum_version_id = 0,
	369	.needed = vmstate_event_facility_mask64_needed,
b9b59a36	370	.fields = (const VMStateField[]) {
98e43b71 CI	371	VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_LOWER], SCLPEventFacility),
	372	VMSTATE_END_OF_LIST()
	373	}
	374	};
	375
bc61c8c6 CI	376	static const VMStateDescription vmstate_event_facility_mask_length = {
	377	.name = "vmstate-event-facility/mask_length",
	378	.version_id = 0,
	379	.minimum_version_id = 0,
	380	.needed = vmstate_event_facility_mask_length_needed,
b9b59a36	381	.fields = (const VMStateField[]) {
bc61c8c6 CI	382	VMSTATE_UINT16(mask_length, SCLPEventFacility),
	383	VMSTATE_END_OF_LIST()
	384	}
	385	};
	386
6fbef18a HG	387	static const VMStateDescription vmstate_event_facility = {
	388	.name = "vmstate-event-facility",
	389	.version_id = 0,
	390	.minimum_version_id = 0,
b9b59a36	391	.fields = (const VMStateField[]) {
98e43b71	392	VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_UPPER], SCLPEventFacility),
6fbef18a	393	VMSTATE_END_OF_LIST()
bc61c8c6	394	},
b9b59a36	395	.subsections = (const VMStateDescription * const []) {
98e43b71	396	&vmstate_event_facility_mask64,
bc61c8c6 CI	397	&vmstate_event_facility_mask_length,
bc61c8c6 CI	398	NULL
6fbef18a HG	399	}
	400	};
	401
bc61c8c6 CI	402	static void sclp_event_set_allow_all_mask_sizes(Object *obj, bool value,
	403	Error **errp)
	404	{
	405	SCLPEventFacility ef = (SCLPEventFacility )obj;
	406
	407	ef->allow_all_mask_sizes = value;
	408	}
	409
547d6459	410	static bool sclp_event_get_allow_all_mask_sizes(Object obj, Error *errp)
bc61c8c6 CI	411	{
	412	SCLPEventFacility ef = (SCLPEventFacility )obj;
	413
	414	return ef->allow_all_mask_sizes;
	415	}
	416
f6102c32	417	static void init_event_facility(Object *obj)
559a17a1	418	{
f6102c32 DH	419	SCLPEventFacility *event_facility = EVENT_FACILITY(obj);
f6102c32 DH	420	DeviceState *sdev = DEVICE(obj);
559a17a1	421
bc61c8c6 CI	422	event_facility->mask_length = 4;
	423	event_facility->allow_all_mask_sizes = true;
	424	object_property_add_bool(obj, "allow_all_mask_sizes",
	425	sclp_event_get_allow_all_mask_sizes,
d2623129	426	sclp_event_set_allow_all_mask_sizes);
1afec9e8	427
477a72a1	428	/* Spawn a new bus for SCLP events */
d637e1dc PM	429	qbus_init(&event_facility->sbus, sizeof(event_facility->sbus),
d637e1dc PM	430	TYPE_SCLP_EVENTS_BUS, sdev, NULL);
559a17a1	431
1afec9e8 MA	432	object_initialize_child(obj, TYPE_SCLP_QUIESCE,
	433	&event_facility->quiesce,
	434	TYPE_SCLP_QUIESCE);
	435
	436	object_initialize_child(obj, TYPE_SCLP_CPU_HOTPLUG,
	437	&event_facility->cpu_hotplug,
	438	TYPE_SCLP_CPU_HOTPLUG);
	439	}
	440
	441	static void realize_event_facility(DeviceState dev, Error *errp)
	442	{
	443	SCLPEventFacility *event_facility = EVENT_FACILITY(dev);
7059384c	444
118bfd76	445	if (!qdev_realize(DEVICE(&event_facility->quiesce),
668f62ec	446	BUS(&event_facility->sbus), errp)) {
1afec9e8 MA	447	return;
1afec9e8 MA	448	}
118bfd76	449	if (!qdev_realize(DEVICE(&event_facility->cpu_hotplug),
668f62ec	450	BUS(&event_facility->sbus), errp)) {
1afec9e8 MA	451	qdev_unrealize(DEVICE(&event_facility->quiesce));
	452	return;
	453	}
559a17a1 HG	454	}
559a17a1 HG	455
3af6de32 HG	456	static void reset_event_facility(DeviceState *dev)
3af6de32 HG	457	{
477a72a1	458	SCLPEventFacility *sdev = EVENT_FACILITY(dev);
3af6de32	459
477a72a1	460	sdev->receive_mask = 0;
3af6de32 HG	461	}
3af6de32 HG	462
559a17a1 HG	463	static void init_event_facility_class(ObjectClass klass, void data)
559a17a1 HG	464	{
477a72a1 HG	465	SysBusDeviceClass *sbdc = SYS_BUS_DEVICE_CLASS(klass);
	466	DeviceClass *dc = DEVICE_CLASS(sbdc);
	467	SCLPEventFacilityClass *k = EVENT_FACILITY_CLASS(dc);
559a17a1	468
1afec9e8	469	dc->realize = realize_event_facility;
3af6de32	470	dc->reset = reset_event_facility;
6fbef18a	471	dc->vmsd = &vmstate_event_facility;
183f6b8d	472	set_bit(DEVICE_CATEGORY_MISC, dc->categories);
477a72a1 HG	473	k->command_handler = command_handler;
477a72a1 HG	474	k->event_pending = event_pending;
559a17a1 HG	475	}
559a17a1 HG	476
65e526c2	477	static const TypeInfo sclp_event_facility_info = {
477a72a1 HG	478	.name = TYPE_SCLP_EVENT_FACILITY,
477a72a1 HG	479	.parent = TYPE_SYS_BUS_DEVICE,
f6102c32	480	.instance_init = init_event_facility,
477a72a1	481	.instance_size = sizeof(SCLPEventFacility),
559a17a1	482	.class_init = init_event_facility_class,
477a72a1	483	.class_size = sizeof(SCLPEventFacilityClass),
559a17a1 HG	484	};
559a17a1 HG	485
c804c2a7	486	static void event_realize(DeviceState qdev, Error *errp)
559a17a1	487	{
c804c2a7	488	SCLPEvent *event = SCLP_EVENT(qdev);
559a17a1 HG	489	SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event);
559a17a1 HG	490
c804c2a7 HG	491	if (child->init) {
	492	int rc = child->init(event);
	493	if (rc < 0) {
	494	error_setg(errp, "SCLP event initialization failed.");
	495	return;
	496	}
	497	}
559a17a1 HG	498	}
559a17a1 HG	499
559a17a1 HG	500	static void event_class_init(ObjectClass klass, void data)
	501	{
	502	DeviceClass *dc = DEVICE_CLASS(klass);
	503
	504	dc->bus_type = TYPE_SCLP_EVENTS_BUS;
c804c2a7	505	dc->realize = event_realize;
559a17a1 HG	506	}
559a17a1 HG	507
65e526c2	508	static const TypeInfo sclp_event_type_info = {
559a17a1 HG	509	.name = TYPE_SCLP_EVENT,
	510	.parent = TYPE_DEVICE,
	511	.instance_size = sizeof(SCLPEvent),
	512	.class_init = event_class_init,
	513	.class_size = sizeof(SCLPEventClass),
	514	.abstract = true,
	515	};
	516
	517	static void register_types(void)
	518	{
65e526c2 HG	519	type_register_static(&sclp_events_bus_info);
	520	type_register_static(&sclp_event_facility_info);
	521	type_register_static(&sclp_event_type_info);
559a17a1 HG	522	}
	523
	524	type_init(register_types)
052888f0	525
af4a3e32	526	BusState sclp_get_event_facility_bus(SCLPEventFacility ef)
052888f0	527	{
af4a3e32	528	return BUS(&ef->sbus);
052888f0	529	}