2012-10-29 03:13:23 +01:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-01-26 19:17:00 +01:00
|
|
|
#include "qemu/osdep.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2019-05-23 16:35:07 +02:00
|
|
|
#include "qemu/module.h"
|
2012-10-29 03:13:23 +01:00
|
|
|
|
2013-02-04 15:40:22 +01:00
|
|
|
#include "hw/s390x/sclp.h"
|
2019-08-12 07:23:45 +02:00
|
|
|
#include "migration/vmstate.h"
|
2013-02-04 15:40:22 +01:00
|
|
|
#include "hw/s390x/event-facility.h"
|
2012-10-29 03:13:23 +01:00
|
|
|
|
2013-12-23 10:25:38 +01:00
|
|
|
typedef struct SCLPEventsBus {
|
2012-10-29 03:13:23 +01:00
|
|
|
BusState qbus;
|
2013-12-23 10:25:38 +01:00
|
|
|
} SCLPEventsBus;
|
2012-10-29 03:13:23 +01:00
|
|
|
|
2018-03-08 12:04:29 +01:00
|
|
|
/* 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
|
|
|
|
|
2012-10-29 03:13:23 +01:00
|
|
|
struct SCLPEventFacility {
|
2013-12-18 10:10:49 +01:00
|
|
|
SysBusDevice parent_obj;
|
2013-12-23 10:25:38 +01:00
|
|
|
SCLPEventsBus sbus;
|
2018-02-23 18:42:57 +01:00
|
|
|
/* guest's receive mask */
|
2018-03-08 12:04:29 +01:00
|
|
|
union {
|
|
|
|
uint32_t receive_mask_pieces[2];
|
|
|
|
sccb_mask_t receive_mask;
|
|
|
|
};
|
s390x/sclp: proper support of larger send and receive masks
Until 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
we only supported sclp event masks with a size of exactly 4 bytes, even
though the architecture allows the guests to set up sclp event masks
from 1 to 1021 bytes in length.
After that patch, the behaviour was almost compliant, but some issues
were still remaining, in particular regarding the handling of selective
reads and migration.
When setting the sclp event mask, a mask size is also specified. Until
now we only considered the size in order to decide which bits to save
in the internal state. On the other hand, when a guest performs a
selective read, it sends a mask, but it does not specify a size; the
implied size is the size of the last mask that has been set.
Specifying bits in the mask of selective read that are not available in
the internal mask should return an error, and bits past the end of the
mask should obviously be ignored. This can only be achieved by keeping
track of the lenght of the mask.
The mask length is thus now part of the internal state that needs to be
migrated.
This patch fixes the handling of selective reads, whose size will now
match the length of the event mask, as per architecture.
While the default behaviour is to be compliant with the architecture,
when using older machine models the old broken behaviour is selected
(allowing only masks of size exactly 4), in order to be able to migrate
toward older versions.
Fixes: 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
Signed-off-by: Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
Message-Id: <1519407778-23095-2-git-send-email-imbrenda@linux.vnet.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-23 18:42:56 +01:00
|
|
|
/*
|
|
|
|
* 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;
|
2012-10-29 03:13:23 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2018-02-23 18:42:57 +01:00
|
|
|
static sccb_mask_t get_host_send_mask(SCLPEventFacility *ef)
|
2012-10-29 03:13:23 +01:00
|
|
|
{
|
2018-02-23 18:42:57 +01:00
|
|
|
sccb_mask_t mask;
|
2012-10-29 03:13:23 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-02-23 18:42:57 +01:00
|
|
|
static sccb_mask_t get_host_receive_mask(SCLPEventFacility *ef)
|
2012-10-29 03:13:23 +01:00
|
|
|
{
|
2018-02-23 18:42:57 +01:00
|
|
|
sccb_mask_t mask;
|
2012-10-29 03:13:23 +01:00
|
|
|
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;
|
|
|
|
|
2012-11-23 01:18:12 +01:00
|
|
|
rc = SCLP_RC_INVALID_FUNCTION;
|
|
|
|
|
2012-10-29 03:13:23 +01:00
|
|
|
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 &&
|
2013-09-17 13:07:30 +02:00
|
|
|
ec->can_handle_event(event_buf->type)) {
|
2012-10-29 03:13:23 +01:00
|
|
|
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,
|
2018-02-23 18:42:57 +01:00
|
|
|
sccb_mask_t mask)
|
2012-10-29 03:13:23 +01:00
|
|
|
{
|
|
|
|
uint16_t rc;
|
|
|
|
int slen;
|
2013-08-19 09:41:24 +02:00
|
|
|
unsigned elen;
|
2012-10-29 03:13:23 +01:00
|
|
|
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)) {
|
2013-08-19 09:41:24 +02:00
|
|
|
elen = be16_to_cpu(event_buf->length);
|
|
|
|
event_buf = (EventBufferHeader *) ((char *)event_buf + elen);
|
2012-10-29 03:13:23 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
s390x/sclp: proper support of larger send and receive masks
Until 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
we only supported sclp event masks with a size of exactly 4 bytes, even
though the architecture allows the guests to set up sclp event masks
from 1 to 1021 bytes in length.
After that patch, the behaviour was almost compliant, but some issues
were still remaining, in particular regarding the handling of selective
reads and migration.
When setting the sclp event mask, a mask size is also specified. Until
now we only considered the size in order to decide which bits to save
in the internal state. On the other hand, when a guest performs a
selective read, it sends a mask, but it does not specify a size; the
implied size is the size of the last mask that has been set.
Specifying bits in the mask of selective read that are not available in
the internal mask should return an error, and bits past the end of the
mask should obviously be ignored. This can only be achieved by keeping
track of the lenght of the mask.
The mask length is thus now part of the internal state that needs to be
migrated.
This patch fixes the handling of selective reads, whose size will now
match the length of the event mask, as per architecture.
While the default behaviour is to be compliant with the architecture,
when using older machine models the old broken behaviour is selected
(allowing only masks of size exactly 4), in order to be able to migrate
toward older versions.
Fixes: 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
Signed-off-by: Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
Message-Id: <1519407778-23095-2-git-send-email-imbrenda@linux.vnet.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-23 18:42:56 +01:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-29 03:13:23 +01:00
|
|
|
static void read_event_data(SCLPEventFacility *ef, SCCB *sccb)
|
|
|
|
{
|
2018-02-23 18:42:57 +01:00
|
|
|
sccb_mask_t sclp_active_selection_mask;
|
|
|
|
sccb_mask_t sclp_cp_receive_mask;
|
2012-10-29 03:13:23 +01:00
|
|
|
|
|
|
|
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:
|
s390x/sclp: proper support of larger send and receive masks
Until 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
we only supported sclp event masks with a size of exactly 4 bytes, even
though the architecture allows the guests to set up sclp event masks
from 1 to 1021 bytes in length.
After that patch, the behaviour was almost compliant, but some issues
were still remaining, in particular regarding the handling of selective
reads and migration.
When setting the sclp event mask, a mask size is also specified. Until
now we only considered the size in order to decide which bits to save
in the internal state. On the other hand, when a guest performs a
selective read, it sends a mask, but it does not specify a size; the
implied size is the size of the last mask that has been set.
Specifying bits in the mask of selective read that are not available in
the internal mask should return an error, and bits past the end of the
mask should obviously be ignored. This can only be achieved by keeping
track of the lenght of the mask.
The mask length is thus now part of the internal state that needs to be
migrated.
This patch fixes the handling of selective reads, whose size will now
match the length of the event mask, as per architecture.
While the default behaviour is to be compliant with the architecture,
when using older machine models the old broken behaviour is selected
(allowing only masks of size exactly 4), in order to be able to migrate
toward older versions.
Fixes: 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
Signed-off-by: Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
Message-Id: <1519407778-23095-2-git-send-email-imbrenda@linux.vnet.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-23 18:42:56 +01:00
|
|
|
copy_mask((uint8_t *)&sclp_active_selection_mask, (uint8_t *)&red->mask,
|
|
|
|
sizeof(sclp_active_selection_mask), ef->mask_length);
|
2018-03-08 12:04:29 +01:00
|
|
|
sclp_active_selection_mask = be64_to_cpu(sclp_active_selection_mask);
|
2015-07-01 15:28:06 +02:00
|
|
|
if (!sclp_cp_receive_mask ||
|
|
|
|
(sclp_active_selection_mask & ~sclp_cp_receive_mask)) {
|
2012-10-29 03:13:23 +01:00
|
|
|
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;
|
2017-10-11 15:39:53 +02:00
|
|
|
uint16_t mask_length = be16_to_cpu(we_mask->mask_length);
|
2018-02-23 18:42:57 +01:00
|
|
|
sccb_mask_t tmp_mask;
|
2012-10-29 03:13:23 +01:00
|
|
|
|
s390x/sclp: proper support of larger send and receive masks
Until 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
we only supported sclp event masks with a size of exactly 4 bytes, even
though the architecture allows the guests to set up sclp event masks
from 1 to 1021 bytes in length.
After that patch, the behaviour was almost compliant, but some issues
were still remaining, in particular regarding the handling of selective
reads and migration.
When setting the sclp event mask, a mask size is also specified. Until
now we only considered the size in order to decide which bits to save
in the internal state. On the other hand, when a guest performs a
selective read, it sends a mask, but it does not specify a size; the
implied size is the size of the last mask that has been set.
Specifying bits in the mask of selective read that are not available in
the internal mask should return an error, and bits past the end of the
mask should obviously be ignored. This can only be achieved by keeping
track of the lenght of the mask.
The mask length is thus now part of the internal state that needs to be
migrated.
This patch fixes the handling of selective reads, whose size will now
match the length of the event mask, as per architecture.
While the default behaviour is to be compliant with the architecture,
when using older machine models the old broken behaviour is selected
(allowing only masks of size exactly 4), in order to be able to migrate
toward older versions.
Fixes: 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
Signed-off-by: Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
Message-Id: <1519407778-23095-2-git-send-email-imbrenda@linux.vnet.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-23 18:42:56 +01:00
|
|
|
if (!mask_length || (mask_length > SCLP_EVENT_MASK_LEN_MAX) ||
|
|
|
|
((mask_length != 4) && !ef->allow_all_mask_sizes)) {
|
2012-10-29 03:13:23 +01:00
|
|
|
sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_MASK_LENGTH);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2017-10-11 15:39:53 +02:00
|
|
|
/*
|
2018-03-08 12:04:29 +01:00
|
|
|
* 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.
|
2017-10-11 15:39:53 +02:00
|
|
|
*/
|
|
|
|
|
2012-10-29 03:13:23 +01:00
|
|
|
/* keep track of the guest's capability masks */
|
2017-10-11 15:39:53 +02:00
|
|
|
copy_mask((uint8_t *)&tmp_mask, WEM_CP_RECEIVE_MASK(we_mask, mask_length),
|
|
|
|
sizeof(tmp_mask), mask_length);
|
2018-03-08 12:04:29 +01:00
|
|
|
ef->receive_mask = be64_to_cpu(tmp_mask);
|
2012-10-29 03:13:23 +01:00
|
|
|
|
|
|
|
/* return the SCLP's capability masks to the guest */
|
2018-03-08 12:04:29 +01:00
|
|
|
tmp_mask = cpu_to_be64(get_host_receive_mask(ef));
|
2017-10-11 15:39:53 +02:00
|
|
|
copy_mask(WEM_RECEIVE_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
|
|
|
|
mask_length, sizeof(tmp_mask));
|
2018-03-08 12:04:29 +01:00
|
|
|
tmp_mask = cpu_to_be64(get_host_send_mask(ef));
|
2017-10-11 15:39:53 +02:00
|
|
|
copy_mask(WEM_SEND_MASK(we_mask, mask_length), (uint8_t *)&tmp_mask,
|
|
|
|
mask_length, sizeof(tmp_mask));
|
2012-10-29 03:13:23 +01:00
|
|
|
|
|
|
|
sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
|
s390x/sclp: proper support of larger send and receive masks
Until 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
we only supported sclp event masks with a size of exactly 4 bytes, even
though the architecture allows the guests to set up sclp event masks
from 1 to 1021 bytes in length.
After that patch, the behaviour was almost compliant, but some issues
were still remaining, in particular regarding the handling of selective
reads and migration.
When setting the sclp event mask, a mask size is also specified. Until
now we only considered the size in order to decide which bits to save
in the internal state. On the other hand, when a guest performs a
selective read, it sends a mask, but it does not specify a size; the
implied size is the size of the last mask that has been set.
Specifying bits in the mask of selective read that are not available in
the internal mask should return an error, and bits past the end of the
mask should obviously be ignored. This can only be achieved by keeping
track of the lenght of the mask.
The mask length is thus now part of the internal state that needs to be
migrated.
This patch fixes the handling of selective reads, whose size will now
match the length of the event mask, as per architecture.
While the default behaviour is to be compliant with the architecture,
when using older machine models the old broken behaviour is selected
(allowing only masks of size exactly 4), in order to be able to migrate
toward older versions.
Fixes: 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
Signed-off-by: Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
Message-Id: <1519407778-23095-2-git-send-email-imbrenda@linux.vnet.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-23 18:42:56 +01:00
|
|
|
ef->mask_length = mask_length;
|
2012-10-29 03:13:23 +01:00
|
|
|
|
|
|
|
out:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* qemu object creation and initialization functions */
|
|
|
|
|
|
|
|
#define TYPE_SCLP_EVENTS_BUS "s390-sclp-events-bus"
|
|
|
|
|
2015-05-21 12:43:31 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-29 03:13:23 +01:00
|
|
|
static void sclp_events_bus_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
2015-05-21 12:43:31 +02:00
|
|
|
BusClass *bc = BUS_CLASS(klass);
|
|
|
|
|
|
|
|
bc->realize = sclp_events_bus_realize;
|
2012-10-29 03:13:23 +01:00
|
|
|
}
|
|
|
|
|
2013-12-23 10:25:38 +01:00
|
|
|
static const TypeInfo sclp_events_bus_info = {
|
2012-10-29 03:13:23 +01:00
|
|
|
.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)
|
|
|
|
{
|
2014-02-07 13:41:58 +01:00
|
|
|
switch (code & SCLP_CMD_CODE_MASK) {
|
2012-10-29 03:13:23 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-08 12:04:29 +01:00
|
|
|
static bool vmstate_event_facility_mask64_needed(void *opaque)
|
|
|
|
{
|
|
|
|
SCLPEventFacility *ef = opaque;
|
|
|
|
|
|
|
|
return (ef->receive_mask & 0xFFFFFFFF) != 0;
|
|
|
|
}
|
|
|
|
|
s390x/sclp: proper support of larger send and receive masks
Until 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
we only supported sclp event masks with a size of exactly 4 bytes, even
though the architecture allows the guests to set up sclp event masks
from 1 to 1021 bytes in length.
After that patch, the behaviour was almost compliant, but some issues
were still remaining, in particular regarding the handling of selective
reads and migration.
When setting the sclp event mask, a mask size is also specified. Until
now we only considered the size in order to decide which bits to save
in the internal state. On the other hand, when a guest performs a
selective read, it sends a mask, but it does not specify a size; the
implied size is the size of the last mask that has been set.
Specifying bits in the mask of selective read that are not available in
the internal mask should return an error, and bits past the end of the
mask should obviously be ignored. This can only be achieved by keeping
track of the lenght of the mask.
The mask length is thus now part of the internal state that needs to be
migrated.
This patch fixes the handling of selective reads, whose size will now
match the length of the event mask, as per architecture.
While the default behaviour is to be compliant with the architecture,
when using older machine models the old broken behaviour is selected
(allowing only masks of size exactly 4), in order to be able to migrate
toward older versions.
Fixes: 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
Signed-off-by: Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
Message-Id: <1519407778-23095-2-git-send-email-imbrenda@linux.vnet.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-23 18:42:56 +01:00
|
|
|
static bool vmstate_event_facility_mask_length_needed(void *opaque)
|
|
|
|
{
|
|
|
|
SCLPEventFacility *ef = opaque;
|
|
|
|
|
|
|
|
return ef->allow_all_mask_sizes;
|
|
|
|
}
|
|
|
|
|
2018-03-08 12:04:29 +01:00
|
|
|
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()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
s390x/sclp: proper support of larger send and receive masks
Until 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
we only supported sclp event masks with a size of exactly 4 bytes, even
though the architecture allows the guests to set up sclp event masks
from 1 to 1021 bytes in length.
After that patch, the behaviour was almost compliant, but some issues
were still remaining, in particular regarding the handling of selective
reads and migration.
When setting the sclp event mask, a mask size is also specified. Until
now we only considered the size in order to decide which bits to save
in the internal state. On the other hand, when a guest performs a
selective read, it sends a mask, but it does not specify a size; the
implied size is the size of the last mask that has been set.
Specifying bits in the mask of selective read that are not available in
the internal mask should return an error, and bits past the end of the
mask should obviously be ignored. This can only be achieved by keeping
track of the lenght of the mask.
The mask length is thus now part of the internal state that needs to be
migrated.
This patch fixes the handling of selective reads, whose size will now
match the length of the event mask, as per architecture.
While the default behaviour is to be compliant with the architecture,
when using older machine models the old broken behaviour is selected
(allowing only masks of size exactly 4), in order to be able to migrate
toward older versions.
Fixes: 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
Signed-off-by: Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
Message-Id: <1519407778-23095-2-git-send-email-imbrenda@linux.vnet.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-23 18:42:56 +01:00
|
|
|
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()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-12-18 13:59:57 +01:00
|
|
|
static const VMStateDescription vmstate_event_facility = {
|
|
|
|
.name = "vmstate-event-facility",
|
|
|
|
.version_id = 0,
|
|
|
|
.minimum_version_id = 0,
|
2014-04-16 16:01:33 +02:00
|
|
|
.fields = (VMStateField[]) {
|
2018-03-08 12:04:29 +01:00
|
|
|
VMSTATE_UINT32(receive_mask_pieces[RECV_MASK_UPPER], SCLPEventFacility),
|
2013-12-18 13:59:57 +01:00
|
|
|
VMSTATE_END_OF_LIST()
|
s390x/sclp: proper support of larger send and receive masks
Until 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
we only supported sclp event masks with a size of exactly 4 bytes, even
though the architecture allows the guests to set up sclp event masks
from 1 to 1021 bytes in length.
After that patch, the behaviour was almost compliant, but some issues
were still remaining, in particular regarding the handling of selective
reads and migration.
When setting the sclp event mask, a mask size is also specified. Until
now we only considered the size in order to decide which bits to save
in the internal state. On the other hand, when a guest performs a
selective read, it sends a mask, but it does not specify a size; the
implied size is the size of the last mask that has been set.
Specifying bits in the mask of selective read that are not available in
the internal mask should return an error, and bits past the end of the
mask should obviously be ignored. This can only be achieved by keeping
track of the lenght of the mask.
The mask length is thus now part of the internal state that needs to be
migrated.
This patch fixes the handling of selective reads, whose size will now
match the length of the event mask, as per architecture.
While the default behaviour is to be compliant with the architecture,
when using older machine models the old broken behaviour is selected
(allowing only masks of size exactly 4), in order to be able to migrate
toward older versions.
Fixes: 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
Signed-off-by: Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
Message-Id: <1519407778-23095-2-git-send-email-imbrenda@linux.vnet.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-23 18:42:56 +01:00
|
|
|
},
|
|
|
|
.subsections = (const VMStateDescription * []) {
|
2018-03-08 12:04:29 +01:00
|
|
|
&vmstate_event_facility_mask64,
|
s390x/sclp: proper support of larger send and receive masks
Until 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
we only supported sclp event masks with a size of exactly 4 bytes, even
though the architecture allows the guests to set up sclp event masks
from 1 to 1021 bytes in length.
After that patch, the behaviour was almost compliant, but some issues
were still remaining, in particular regarding the handling of selective
reads and migration.
When setting the sclp event mask, a mask size is also specified. Until
now we only considered the size in order to decide which bits to save
in the internal state. On the other hand, when a guest performs a
selective read, it sends a mask, but it does not specify a size; the
implied size is the size of the last mask that has been set.
Specifying bits in the mask of selective read that are not available in
the internal mask should return an error, and bits past the end of the
mask should obviously be ignored. This can only be achieved by keeping
track of the lenght of the mask.
The mask length is thus now part of the internal state that needs to be
migrated.
This patch fixes the handling of selective reads, whose size will now
match the length of the event mask, as per architecture.
While the default behaviour is to be compliant with the architecture,
when using older machine models the old broken behaviour is selected
(allowing only masks of size exactly 4), in order to be able to migrate
toward older versions.
Fixes: 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
Signed-off-by: Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
Message-Id: <1519407778-23095-2-git-send-email-imbrenda@linux.vnet.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-23 18:42:56 +01:00
|
|
|
&vmstate_event_facility_mask_length,
|
|
|
|
NULL
|
2013-12-18 13:59:57 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
s390x/sclp: proper support of larger send and receive masks
Until 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
we only supported sclp event masks with a size of exactly 4 bytes, even
though the architecture allows the guests to set up sclp event masks
from 1 to 1021 bytes in length.
After that patch, the behaviour was almost compliant, but some issues
were still remaining, in particular regarding the handling of selective
reads and migration.
When setting the sclp event mask, a mask size is also specified. Until
now we only considered the size in order to decide which bits to save
in the internal state. On the other hand, when a guest performs a
selective read, it sends a mask, but it does not specify a size; the
implied size is the size of the last mask that has been set.
Specifying bits in the mask of selective read that are not available in
the internal mask should return an error, and bits past the end of the
mask should obviously be ignored. This can only be achieved by keeping
track of the lenght of the mask.
The mask length is thus now part of the internal state that needs to be
migrated.
This patch fixes the handling of selective reads, whose size will now
match the length of the event mask, as per architecture.
While the default behaviour is to be compliant with the architecture,
when using older machine models the old broken behaviour is selected
(allowing only masks of size exactly 4), in order to be able to migrate
toward older versions.
Fixes: 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
Signed-off-by: Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
Message-Id: <1519407778-23095-2-git-send-email-imbrenda@linux.vnet.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-23 18:42:56 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-05-21 12:43:31 +02:00
|
|
|
static void init_event_facility(Object *obj)
|
2012-10-29 03:13:23 +01:00
|
|
|
{
|
2015-05-21 12:43:31 +02:00
|
|
|
SCLPEventFacility *event_facility = EVENT_FACILITY(obj);
|
|
|
|
DeviceState *sdev = DEVICE(obj);
|
2015-10-01 10:49:45 +02:00
|
|
|
Object *new;
|
2012-10-29 03:13:23 +01:00
|
|
|
|
s390x/sclp: proper support of larger send and receive masks
Until 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
we only supported sclp event masks with a size of exactly 4 bytes, even
though the architecture allows the guests to set up sclp event masks
from 1 to 1021 bytes in length.
After that patch, the behaviour was almost compliant, but some issues
were still remaining, in particular regarding the handling of selective
reads and migration.
When setting the sclp event mask, a mask size is also specified. Until
now we only considered the size in order to decide which bits to save
in the internal state. On the other hand, when a guest performs a
selective read, it sends a mask, but it does not specify a size; the
implied size is the size of the last mask that has been set.
Specifying bits in the mask of selective read that are not available in
the internal mask should return an error, and bits past the end of the
mask should obviously be ignored. This can only be achieved by keeping
track of the lenght of the mask.
The mask length is thus now part of the internal state that needs to be
migrated.
This patch fixes the handling of selective reads, whose size will now
match the length of the event mask, as per architecture.
While the default behaviour is to be compliant with the architecture,
when using older machine models the old broken behaviour is selected
(allowing only masks of size exactly 4), in order to be able to migrate
toward older versions.
Fixes: 67915de9f0383ccf4a ("s390x/event-facility: variable-length event masks")
Signed-off-by: Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
Message-Id: <1519407778-23095-2-git-send-email-imbrenda@linux.vnet.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-23 18:42:56 +01:00
|
|
|
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);
|
2013-12-18 10:10:49 +01:00
|
|
|
/* Spawn a new bus for SCLP events */
|
2013-08-24 00:02:27 +02:00
|
|
|
qbus_create_inplace(&event_facility->sbus, sizeof(event_facility->sbus),
|
2013-12-18 10:10:49 +01:00
|
|
|
TYPE_SCLP_EVENTS_BUS, sdev, NULL);
|
2012-10-29 03:13:23 +01:00
|
|
|
|
2015-10-01 10:49:45 +02:00
|
|
|
new = object_new(TYPE_SCLP_QUIESCE);
|
|
|
|
object_property_add_child(obj, TYPE_SCLP_QUIESCE, new, NULL);
|
|
|
|
object_unref(new);
|
2019-05-28 18:40:14 +02:00
|
|
|
qdev_set_parent_bus(DEVICE(new), BUS(&event_facility->sbus));
|
2015-10-01 10:49:45 +02:00
|
|
|
|
|
|
|
new = object_new(TYPE_SCLP_CPU_HOTPLUG);
|
|
|
|
object_property_add_child(obj, TYPE_SCLP_CPU_HOTPLUG, new, NULL);
|
|
|
|
object_unref(new);
|
2019-05-28 18:40:14 +02:00
|
|
|
qdev_set_parent_bus(DEVICE(new), BUS(&event_facility->sbus));
|
2015-05-21 12:43:31 +02:00
|
|
|
/* the facility will automatically realize the devices via the bus */
|
2012-10-29 03:13:23 +01:00
|
|
|
}
|
|
|
|
|
2013-09-04 12:55:45 +02:00
|
|
|
static void reset_event_facility(DeviceState *dev)
|
|
|
|
{
|
2013-12-18 10:10:49 +01:00
|
|
|
SCLPEventFacility *sdev = EVENT_FACILITY(dev);
|
2013-09-04 12:55:45 +02:00
|
|
|
|
2013-12-18 10:10:49 +01:00
|
|
|
sdev->receive_mask = 0;
|
2013-09-04 12:55:45 +02:00
|
|
|
}
|
|
|
|
|
2012-10-29 03:13:23 +01:00
|
|
|
static void init_event_facility_class(ObjectClass *klass, void *data)
|
|
|
|
{
|
2013-12-18 10:10:49 +01:00
|
|
|
SysBusDeviceClass *sbdc = SYS_BUS_DEVICE_CLASS(klass);
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(sbdc);
|
|
|
|
SCLPEventFacilityClass *k = EVENT_FACILITY_CLASS(dc);
|
2012-10-29 03:13:23 +01:00
|
|
|
|
2013-09-04 12:55:45 +02:00
|
|
|
dc->reset = reset_event_facility;
|
2013-12-18 13:59:57 +01:00
|
|
|
dc->vmsd = &vmstate_event_facility;
|
2015-03-17 13:44:39 +01:00
|
|
|
set_bit(DEVICE_CATEGORY_MISC, dc->categories);
|
2013-12-18 10:10:49 +01:00
|
|
|
k->command_handler = command_handler;
|
|
|
|
k->event_pending = event_pending;
|
2012-10-29 03:13:23 +01:00
|
|
|
}
|
|
|
|
|
2013-12-23 10:25:38 +01:00
|
|
|
static const TypeInfo sclp_event_facility_info = {
|
2013-12-18 10:10:49 +01:00
|
|
|
.name = TYPE_SCLP_EVENT_FACILITY,
|
|
|
|
.parent = TYPE_SYS_BUS_DEVICE,
|
2015-05-21 12:43:31 +02:00
|
|
|
.instance_init = init_event_facility,
|
2013-12-18 10:10:49 +01:00
|
|
|
.instance_size = sizeof(SCLPEventFacility),
|
2012-10-29 03:13:23 +01:00
|
|
|
.class_init = init_event_facility_class,
|
2013-12-18 10:10:49 +01:00
|
|
|
.class_size = sizeof(SCLPEventFacilityClass),
|
2012-10-29 03:13:23 +01:00
|
|
|
};
|
|
|
|
|
2013-12-20 12:02:17 +01:00
|
|
|
static void event_realize(DeviceState *qdev, Error **errp)
|
2012-10-29 03:13:23 +01:00
|
|
|
{
|
2013-12-20 12:02:17 +01:00
|
|
|
SCLPEvent *event = SCLP_EVENT(qdev);
|
2012-10-29 03:13:23 +01:00
|
|
|
SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event);
|
|
|
|
|
2013-12-20 12:02:17 +01:00
|
|
|
if (child->init) {
|
|
|
|
int rc = child->init(event);
|
|
|
|
if (rc < 0) {
|
|
|
|
error_setg(errp, "SCLP event initialization failed.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2012-10-29 03:13:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void event_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
|
|
|
|
dc->bus_type = TYPE_SCLP_EVENTS_BUS;
|
2013-12-20 12:02:17 +01:00
|
|
|
dc->realize = event_realize;
|
2012-10-29 03:13:23 +01:00
|
|
|
}
|
|
|
|
|
2013-12-23 10:25:38 +01:00
|
|
|
static const TypeInfo sclp_event_type_info = {
|
2012-10-29 03:13:23 +01:00
|
|
|
.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)
|
|
|
|
{
|
2013-12-23 10:25:38 +01:00
|
|
|
type_register_static(&sclp_events_bus_info);
|
|
|
|
type_register_static(&sclp_event_facility_info);
|
|
|
|
type_register_static(&sclp_event_type_info);
|
2012-10-29 03:13:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
type_init(register_types)
|
hw/s390x: Allow to configure the consoles with the "-serial" parameter
The consoles ("sclpconsole" and "sclplmconsole") can only be configured
with "-device" and "-chardev" so far. Other machines use the convenience
option "-serial" to configure the default consoles, even for virtual
consoles like spapr-vty on the pseries machine. So let's support this
option on s390x, too. This way we can easily enable the serial console
here again with "-nodefaults", for example:
qemu-system-s390x -no-shutdown -nographic -nodefaults -serial mon:stdio
... which is way shorter than typing:
qemu-system-s390x -no-shutdown -nographic -nodefaults \
-chardev stdio,id=c1,mux=on -device sclpconsole,chardev=c1 \
-mon chardev=c1
The -serial parameter can also be used if you only want to see the QEMU
monitor on stdio without using -nodefaults, but not the console output.
That's something that is pretty impossible with the current code today:
qemu-system-s390x -no-shutdown -nographic -serial none
While we're at it, this patch also maps the second -serial option to the
"sclplmconsole", so that there is now an easy way to configure this second
console on s390x, too, for example:
qemu-system-s390x -no-shutdown -nographic -serial null -serial mon:stdio
Additionally, the new code is also smaller than the old one and we have
less s390x-specific code in vl.c :-)
I've also checked that migration still works as expected by migrating
a guest with console output back and forth between a qemu-system-s390x
that has this patch and an instance without this patch.
Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-Id: <1524754794-28005-1-git-send-email-thuth@redhat.com>
Reviewed-by: David Hildenbrand <david@redhat.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-04-26 16:59:54 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|