[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 <[email protected]>
 *
 * 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 */
#ifdef HOST_WORDS_BIGENDIAN
#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;
    /* 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) {
        DeviceState *qdev = kid->child;
        event = DO_UPCAST(SCLPEvent, qdev, qdev);
        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);
        goto out;
    }
    if (be16_to_cpu(sccb->h.length) < 8) {
        sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
        goto out;
    }
    /* 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));
    }

out:
    return;
}

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 = sizeof(sccb->data);

    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);
        goto out;
    }

    sclp_cp_receive_mask = ef->receive_mask;

    /* get active selection mask */
    switch (sccb->h.function_code) {
    case SCLP_UNCONDITIONAL_READ:
        sclp_active_selection_mask = sclp_cp_receive_mask;
        break;
    case SCLP_SELECTIVE_READ:
        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);
            goto out;
        }
        break;
    default:
        sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION);
        goto out;
    }
    sccb->h.response_code = cpu_to_be16(
            handle_sccb_read_events(ef, sccb, sclp_active_selection_mask));

out:
    return;
}

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);
        goto out;
    }

    /*
     * 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;

out:
    return;
}

/* qemu object creation and initialization functions */

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

static void sclp_events_bus_realize(BusState *bus, Error **errp)
{
    BusChild *kid;

    /* TODO: recursive realization has to be done in common code */
    QTAILQ_FOREACH(kid, &bus->children, sibling) {
        DeviceState *dev = kid->child;

        object_property_set_bool(OBJECT(dev), true, "realized", errp);
        if (*errp) {
            return;
        }
    }
}

static void sclp_events_bus_class_init(ObjectClass *klass, void *data)
{
    BusClass *bc = BUS_CLASS(klass);

    bc->realize = sclp_events_bus_realize;
}

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

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;
    default:
        sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
        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 = (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 = (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 = (VMStateField[]) {
        VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_UPPER], SCLPEventFacility),
        VMSTATE_END_OF_LIST()
     },
    .subsections = (const VMStateDescription * []) {
        &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 **e)
{
    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);
    Object *new;

    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, NULL);
    /* Spawn a new bus for SCLP events */
    qbus_create_inplace(&event_facility->sbus, sizeof(event_facility->sbus),
                        TYPE_SCLP_EVENTS_BUS, sdev, NULL);

    new = object_new(TYPE_SCLP_QUIESCE);
    object_property_add_child(obj, TYPE_SCLP_QUIESCE, new, NULL);
    object_unref(new);
    qdev_set_parent_bus(DEVICE(new), BUS(&event_facility->sbus));

    new = object_new(TYPE_SCLP_CPU_HOTPLUG);
    object_property_add_child(obj, TYPE_SCLP_CPU_HOTPLUG, new, NULL);
    object_unref(new);
    qdev_set_parent_bus(DEVICE(new), BUS(&event_facility->sbus));
    /* the facility will automatically realize the devices via the bus */
}

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->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(void)
{
    Object *busobj;
    SCLPEventsBus *sbus;

    busobj = object_resolve_path_type("", TYPE_SCLP_EVENTS_BUS, NULL);
    sbus = OBJECT_CHECK(SCLPEventsBus, busobj, TYPE_SCLP_EVENTS_BUS);
    if (!sbus) {
        return NULL;
    }

    return &sbus->qbus;
}
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 <[email protected]>
	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 CI	30	/* we need to save 32 bit chunks for compatibility */
	31	#ifdef HOST_WORDS_BIGENDIAN
	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;
1ffed98f	42	/* guest's receive mask */
98e43b71 CI	43	union {
	44	uint32_t receive_mask_pieces[2];
	45	sccb_mask_t receive_mask;
	46	};
bc61c8c6 CI	47	/*
	48	* when false, we keep the same broken, backwards compatible behaviour as
	49	* before, allowing only masks of size exactly 4; when true, we implement
	50	* the architecture correctly, allowing all valid mask sizes. Needed for
	51	* migration toward older versions.
	52	*/
	53	bool allow_all_mask_sizes;
	54	/* length of the receive mask */
	55	uint16_t mask_length;
559a17a1 HG	56	};
	57
	58	/* return true if any child has event pending set */
	59	static 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
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);
	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	/* 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	}
	199
	200	out:
	201	return;
	202	}
	203
	204	static uint16_t handle_sccb_read_events(SCLPEventFacility ef, SCCB sccb,
1ffed98f	205	sccb_mask_t mask)
559a17a1 HG	206	{
	207	uint16_t rc;
	208	int slen;
a0c8699b	209	unsigned elen;
559a17a1 HG	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)) {
a0c8699b RH	229	elen = be16_to_cpu(event_buf->length);
a0c8699b RH	230	event_buf = (EventBufferHeader ) ((char )event_buf + elen);
559a17a1 HG	231	rc = SCLP_RC_NORMAL_COMPLETION;
	232	}
	233	}
559a17a1 HG	234	}
	235
	236	if (sccb->h.control_mask[2] & SCLP_VARIABLE_LENGTH_RESPONSE) {
	237	/* architecture suggests to reset variable-length-response bit */
	238	sccb->h.control_mask[2] &= ~SCLP_VARIABLE_LENGTH_RESPONSE;
	239	/* with a new length value */
	240	sccb->h.length = cpu_to_be16(SCCB_SIZE - slen);
	241	}
	242	return rc;
	243	}
	244
bc61c8c6 CI	245	/* copy up to src_len bytes and fill the rest of dst with zeroes */
	246	static 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
559a17a1 HG	256	static void read_event_data(SCLPEventFacility ef, SCCB sccb)
559a17a1 HG	257	{
1ffed98f CI	258	sccb_mask_t sclp_active_selection_mask;
1ffed98f CI	259	sccb_mask_t sclp_cp_receive_mask;
559a17a1 HG	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	/* get active selection mask */
	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:
bc61c8c6 CI	276	copy_mask((uint8_t )&sclp_active_selection_mask, (uint8_t )&red->mask,
bc61c8c6 CI	277	sizeof(sclp_active_selection_mask), ef->mask_length);
98e43b71	278	sclp_active_selection_mask = be64_to_cpu(sclp_active_selection_mask);
3335dddd CH	279	if (!sclp_cp_receive_mask \|\|
3335dddd CH	280	(sclp_active_selection_mask & ~sclp_cp_receive_mask)) {
559a17a1 HG	281	sccb->h.response_code =
	282	cpu_to_be16(SCLP_RC_INVALID_SELECTION_MASK);
	283	goto out;
	284	}
559a17a1 HG	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
	293	out:
	294	return;
	295	}
	296
	297	static void write_event_mask(SCLPEventFacility ef, SCCB sccb)
	298	{
	299	WriteEventMask we_mask = (WriteEventMask ) sccb;
67915de9	300	uint16_t mask_length = be16_to_cpu(we_mask->mask_length);
1ffed98f	301	sccb_mask_t tmp_mask;
559a17a1	302
bc61c8c6 CI	303	if (!mask_length \|\| (mask_length > SCLP_EVENT_MASK_LEN_MAX) \|\|
bc61c8c6 CI	304	((mask_length != 4) && !ef->allow_all_mask_sizes)) {
559a17a1 HG	305	sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_MASK_LENGTH);
	306	goto out;
	307	}
	308
67915de9	309	/*
98e43b71 CI	310	* Note: We currently only support masks up to 8 byte length;
	311	* the remainder is filled up with zeroes. Older Linux
	312	* kernels use a 4 byte mask length, newer ones can use both
	313	* 8 or 4 depending on what is available on the host.
67915de9 CH	314	*/
67915de9 CH	315
559a17a1	316	/* keep track of the guest's capability masks */
67915de9 CH	317	copy_mask((uint8_t *)&tmp_mask, WEM_CP_RECEIVE_MASK(we_mask, mask_length),
67915de9 CH	318	sizeof(tmp_mask), mask_length);
98e43b71	319	ef->receive_mask = be64_to_cpu(tmp_mask);
559a17a1 HG	320
559a17a1 HG	321	/* return the SCLP's capability masks to the guest */
98e43b71	322	tmp_mask = cpu_to_be64(get_host_receive_mask(ef));
67915de9 CH	323	copy_mask(WEM_RECEIVE_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
67915de9 CH	324	mask_length, sizeof(tmp_mask));
98e43b71	325	tmp_mask = cpu_to_be64(get_host_send_mask(ef));
67915de9 CH	326	copy_mask(WEM_SEND_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
67915de9 CH	327	mask_length, sizeof(tmp_mask));
559a17a1 HG	328
559a17a1 HG	329	sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
bc61c8c6	330	ef->mask_length = mask_length;
559a17a1 HG	331
	332	out:
	333	return;
	334	}
	335
	336	/* qemu object creation and initialization functions */
	337
	338	#define TYPE_SCLP_EVENTS_BUS "s390-sclp-events-bus"
	339
f6102c32 DH	340	static void sclp_events_bus_realize(BusState bus, Error *errp)
	341	{
	342	BusChild *kid;
	343
	344	/* TODO: recursive realization has to be done in common code */
	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
559a17a1 HG	355	static void sclp_events_bus_class_init(ObjectClass klass, void data)
559a17a1 HG	356	{
f6102c32 DH	357	BusClass *bc = BUS_CLASS(klass);
	358
	359	bc->realize = sclp_events_bus_realize;
559a17a1 HG	360	}
559a17a1 HG	361
65e526c2	362	static const TypeInfo sclp_events_bus_info = {
559a17a1 HG	363	.name = TYPE_SCLP_EVENTS_BUS,
	364	.parent = TYPE_BUS,
	365	.class_init = sclp_events_bus_class_init,
	366	};
	367
	368	static void command_handler(SCLPEventFacility ef, SCCB sccb, uint64_t code)
	369	{
9da45bb2	370	switch (code & SCLP_CMD_CODE_MASK) {
559a17a1 HG	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	default:
	381	sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
	382	break;
	383	}
	384	}
	385
98e43b71 CI	386	static bool vmstate_event_facility_mask64_needed(void *opaque)
	387	{
	388	SCLPEventFacility *ef = opaque;
	389
	390	return (ef->receive_mask & 0xFFFFFFFF) != 0;
	391	}
	392
bc61c8c6 CI	393	static bool vmstate_event_facility_mask_length_needed(void *opaque)
	394	{
	395	SCLPEventFacility *ef = opaque;
	396
	397	return ef->allow_all_mask_sizes;
	398	}
	399
98e43b71 CI	400	static const VMStateDescription vmstate_event_facility_mask64 = {
	401	.name = "vmstate-event-facility/mask64",
	402	.version_id = 0,
	403	.minimum_version_id = 0,
	404	.needed = vmstate_event_facility_mask64_needed,
	405	.fields = (VMStateField[]) {
	406	VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_LOWER], SCLPEventFacility),
	407	VMSTATE_END_OF_LIST()
	408	}
	409	};
	410
bc61c8c6 CI	411	static const VMStateDescription vmstate_event_facility_mask_length = {
	412	.name = "vmstate-event-facility/mask_length",
	413	.version_id = 0,
	414	.minimum_version_id = 0,
	415	.needed = vmstate_event_facility_mask_length_needed,
	416	.fields = (VMStateField[]) {
	417	VMSTATE_UINT16(mask_length, SCLPEventFacility),
	418	VMSTATE_END_OF_LIST()
	419	}
	420	};
	421
6fbef18a HG	422	static const VMStateDescription vmstate_event_facility = {
	423	.name = "vmstate-event-facility",
	424	.version_id = 0,
	425	.minimum_version_id = 0,
35d08458	426	.fields = (VMStateField[]) {
98e43b71	427	VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_UPPER], SCLPEventFacility),
6fbef18a	428	VMSTATE_END_OF_LIST()
bc61c8c6 CI	429	},
bc61c8c6 CI	430	.subsections = (const VMStateDescription * []) {
98e43b71	431	&vmstate_event_facility_mask64,
bc61c8c6 CI	432	&vmstate_event_facility_mask_length,
bc61c8c6 CI	433	NULL
6fbef18a HG	434	}
	435	};
	436
bc61c8c6 CI	437	static void sclp_event_set_allow_all_mask_sizes(Object *obj, bool value,
	438	Error **errp)
	439	{
	440	SCLPEventFacility ef = (SCLPEventFacility )obj;
	441
	442	ef->allow_all_mask_sizes = value;
	443	}
	444
	445	static bool sclp_event_get_allow_all_mask_sizes(Object obj, Error *e)
	446	{
	447	SCLPEventFacility ef = (SCLPEventFacility )obj;
	448
	449	return ef->allow_all_mask_sizes;
	450	}
	451
f6102c32	452	static void init_event_facility(Object *obj)
559a17a1	453	{
f6102c32 DH	454	SCLPEventFacility *event_facility = EVENT_FACILITY(obj);
f6102c32 DH	455	DeviceState *sdev = DEVICE(obj);
7059384c	456	Object *new;
559a17a1	457
bc61c8c6 CI	458	event_facility->mask_length = 4;
	459	event_facility->allow_all_mask_sizes = true;
	460	object_property_add_bool(obj, "allow_all_mask_sizes",
	461	sclp_event_get_allow_all_mask_sizes,
	462	sclp_event_set_allow_all_mask_sizes, NULL);
477a72a1	463	/* Spawn a new bus for SCLP events */
fb17dfe0	464	qbus_create_inplace(&event_facility->sbus, sizeof(event_facility->sbus),
477a72a1	465	TYPE_SCLP_EVENTS_BUS, sdev, NULL);
559a17a1	466
7059384c DH	467	new = object_new(TYPE_SCLP_QUIESCE);
	468	object_property_add_child(obj, TYPE_SCLP_QUIESCE, new, NULL);
	469	object_unref(new);
5027da92	470	qdev_set_parent_bus(DEVICE(new), BUS(&event_facility->sbus));
7059384c DH	471
	472	new = object_new(TYPE_SCLP_CPU_HOTPLUG);
	473	object_property_add_child(obj, TYPE_SCLP_CPU_HOTPLUG, new, NULL);
	474	object_unref(new);
5027da92	475	qdev_set_parent_bus(DEVICE(new), BUS(&event_facility->sbus));
f6102c32	476	/* the facility will automatically realize the devices via the bus */
559a17a1 HG	477	}
559a17a1 HG	478
3af6de32 HG	479	static void reset_event_facility(DeviceState *dev)
3af6de32 HG	480	{
477a72a1	481	SCLPEventFacility *sdev = EVENT_FACILITY(dev);
3af6de32	482
477a72a1	483	sdev->receive_mask = 0;
3af6de32 HG	484	}
3af6de32 HG	485
559a17a1 HG	486	static void init_event_facility_class(ObjectClass klass, void data)
559a17a1 HG	487	{
477a72a1 HG	488	SysBusDeviceClass *sbdc = SYS_BUS_DEVICE_CLASS(klass);
	489	DeviceClass *dc = DEVICE_CLASS(sbdc);
	490	SCLPEventFacilityClass *k = EVENT_FACILITY_CLASS(dc);
559a17a1	491
3af6de32	492	dc->reset = reset_event_facility;
6fbef18a	493	dc->vmsd = &vmstate_event_facility;
183f6b8d	494	set_bit(DEVICE_CATEGORY_MISC, dc->categories);
477a72a1 HG	495	k->command_handler = command_handler;
477a72a1 HG	496	k->event_pending = event_pending;
559a17a1 HG	497	}
559a17a1 HG	498
65e526c2	499	static const TypeInfo sclp_event_facility_info = {
477a72a1 HG	500	.name = TYPE_SCLP_EVENT_FACILITY,
477a72a1 HG	501	.parent = TYPE_SYS_BUS_DEVICE,
f6102c32	502	.instance_init = init_event_facility,
477a72a1	503	.instance_size = sizeof(SCLPEventFacility),
559a17a1	504	.class_init = init_event_facility_class,
477a72a1	505	.class_size = sizeof(SCLPEventFacilityClass),
559a17a1 HG	506	};
559a17a1 HG	507
c804c2a7	508	static void event_realize(DeviceState qdev, Error *errp)
559a17a1	509	{
c804c2a7	510	SCLPEvent *event = SCLP_EVENT(qdev);
559a17a1 HG	511	SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event);
559a17a1 HG	512
c804c2a7 HG	513	if (child->init) {
	514	int rc = child->init(event);
	515	if (rc < 0) {
	516	error_setg(errp, "SCLP event initialization failed.");
	517	return;
	518	}
	519	}
559a17a1 HG	520	}
559a17a1 HG	521
559a17a1 HG	522	static void event_class_init(ObjectClass klass, void data)
	523	{
	524	DeviceClass *dc = DEVICE_CLASS(klass);
	525
	526	dc->bus_type = TYPE_SCLP_EVENTS_BUS;
c804c2a7	527	dc->realize = event_realize;
559a17a1 HG	528	}
559a17a1 HG	529
65e526c2	530	static const TypeInfo sclp_event_type_info = {
559a17a1 HG	531	.name = TYPE_SCLP_EVENT,
	532	.parent = TYPE_DEVICE,
	533	.instance_size = sizeof(SCLPEvent),
	534	.class_init = event_class_init,
	535	.class_size = sizeof(SCLPEventClass),
	536	.abstract = true,
	537	};
	538
	539	static void register_types(void)
	540	{
65e526c2 HG	541	type_register_static(&sclp_events_bus_info);
	542	type_register_static(&sclp_event_facility_info);
	543	type_register_static(&sclp_event_type_info);
559a17a1 HG	544	}
	545
	546	type_init(register_types)
052888f0 TH	547
	548	BusState *sclp_get_event_facility_bus(void)
	549	{
	550	Object *busobj;
	551	SCLPEventsBus *sbus;
	552
	553	busobj = object_resolve_path_type("", TYPE_SCLP_EVENTS_BUS, NULL);
	554	sbus = OBJECT_CHECK(SCLPEventsBus, busobj, TYPE_SCLP_EVENTS_BUS);
	555	if (!sbus) {
	556	return NULL;
	557	}
	558
	559	return &sbus->qbus;
	560	}