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;
|
2020-06-10 07:32:42 +02:00
|
|
|
SCLPEvent quiesce, cpu_hotplug;
|
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);
|
2020-01-08 15:46:07 +01:00
|
|
|
return;
|
2012-10-29 03:13:23 +01:00
|
|
|
}
|
|
|
|
if (be16_to_cpu(sccb->h.length) < 8) {
|
|
|
|
sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
|
2020-01-08 15:46:07 +01:00
|
|
|
return;
|
2012-10-29 03:13:23 +01:00
|
|
|
}
|
|
|
|
/* 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,
|
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;
|
2020-09-15 21:44:11 +02:00
|
|
|
slen = sccb_data_len(sccb);
|
2012-10-29 03:13:23 +01:00
|
|
|
|
|
|
|
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);
|
2020-01-08 15:46:07 +01:00
|
|
|
return;
|
2012-10-29 03:13:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (sccb->h.function_code) {
|
|
|
|
case SCLP_UNCONDITIONAL_READ:
|
2020-01-08 15:46:07 +01:00
|
|
|
sccb->h.response_code = cpu_to_be16(
|
|
|
|
handle_sccb_read_events(ef, sccb, ef->receive_mask));
|
2012-10-29 03:13:23 +01:00
|
|
|
break;
|
|
|
|
case SCLP_SELECTIVE_READ:
|
2020-01-08 15:46:07 +01:00
|
|
|
/* get active selection mask */
|
|
|
|
sclp_cp_receive_mask = ef->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
|
|
|
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);
|
2020-01-08 15:46:07 +01:00
|
|
|
} else {
|
|
|
|
sccb->h.response_code = cpu_to_be16(
|
|
|
|
handle_sccb_read_events(ef, sccb, sclp_active_selection_mask));
|
2012-10-29 03:13:23 +01:00
|
|
|
}
|
|
|
|
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;
|
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);
|
2020-01-08 15:46:07 +01:00
|
|
|
return;
|
2012-10-29 03:13:23 +01:00
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
/* qemu object creation and initialization functions */
|
|
|
|
|
|
|
|
#define TYPE_SCLP_EVENTS_BUS "s390-sclp-events-bus"
|
|
|
|
|
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,
|
|
|
|
};
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2019-12-05 18:46:28 +01:00
|
|
|
static bool sclp_event_get_allow_all_mask_sizes(Object *obj, Error **errp)
|
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
|
|
|
{
|
|
|
|
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);
|
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,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
sclp_event_set_allow_all_mask_sizes);
|
2020-06-10 07:32:42 +02:00
|
|
|
|
2013-12-18 10:10:49 +01:00
|
|
|
/* Spawn a new bus for SCLP events */
|
2021-09-23 14:11:51 +02:00
|
|
|
qbus_init(&event_facility->sbus, sizeof(event_facility->sbus),
|
|
|
|
TYPE_SCLP_EVENTS_BUS, sdev, NULL);
|
2012-10-29 03:13:23 +01:00
|
|
|
|
2020-06-10 07:32:42 +02:00
|
|
|
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);
|
2015-10-01 10:49:45 +02:00
|
|
|
|
qdev: Use returned bool to check for qdev_realize() etc. failure
Convert
foo(..., &err);
if (err) {
...
}
to
if (!foo(..., &err)) {
...
}
for qdev_realize(), qdev_realize_and_unref(), qbus_realize() and their
wrappers isa_realize_and_unref(), pci_realize_and_unref(),
sysbus_realize(), sysbus_realize_and_unref(), usb_realize_and_unref().
Coccinelle script:
@@
identifier fun = {
isa_realize_and_unref, pci_realize_and_unref, qbus_realize,
qdev_realize, qdev_realize_and_unref, sysbus_realize,
sysbus_realize_and_unref, usb_realize_and_unref
};
expression list args, args2;
typedef Error;
Error *err;
@@
- fun(args, &err, args2);
- if (err)
+ if (!fun(args, &err, args2))
{
...
}
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Nothing to convert there; skipped.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Converted manually.
A few line breaks tidied up manually.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Greg Kurz <groug@kaod.org>
Message-Id: <20200707160613.848843-5-armbru@redhat.com>
2020-07-07 18:05:32 +02:00
|
|
|
if (!qdev_realize(DEVICE(&event_facility->quiesce),
|
error: Eliminate error_propagate() with Coccinelle, part 1
When all we do with an Error we receive into a local variable is
propagating to somewhere else, we can just as well receive it there
right away. Convert
if (!foo(..., &err)) {
...
error_propagate(errp, err);
...
return ...
}
to
if (!foo(..., errp)) {
...
...
return ...
}
where nothing else needs @err. Coccinelle script:
@rule1 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
binary operator op;
constant c1, c2;
symbol false;
@@
if (
(
- fun(args, &err, args2)
+ fun(args, errp, args2)
|
- !fun(args, &err, args2)
+ !fun(args, errp, args2)
|
- fun(args, &err, args2) op c1
+ fun(args, errp, args2) op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
)
}
@rule2 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
expression var;
binary operator op;
constant c1, c2;
symbol false;
@@
- var = fun(args, &err, args2);
+ var = fun(args, errp, args2);
... when != err
if (
(
var
|
!var
|
var op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
|
return var;
)
}
@depends on rule1 || rule2@
identifier err;
@@
- Error *err = NULL;
... when != err
Not exactly elegant, I'm afraid.
The "when != lbl:" is necessary to avoid transforming
if (fun(args, &err)) {
goto out
}
...
out:
error_propagate(errp, err);
even though other paths to label out still need the error_propagate().
For an actual example, see sclp_realize().
Without the "when strict", Coccinelle transforms vfio_msix_setup(),
incorrectly. I don't know what exactly "when strict" does, only that
it helps here.
The match of return is narrower than what I want, but I can't figure
out how to express "return where the operand doesn't use @err". For
an example where it's too narrow, see vfio_intx_enable().
Silently fails to convert hw/arm/armsse.c, because Coccinelle gets
confused by ARMSSE being used both as typedef and function-like macro
there. Converted manually.
Line breaks tidied up manually. One nested declaration of @local_err
deleted manually. Preexisting unwanted blank line dropped in
hw/riscv/sifive_e.c.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20200707160613.848843-35-armbru@redhat.com>
2020-07-07 18:06:02 +02:00
|
|
|
BUS(&event_facility->sbus), errp)) {
|
2020-06-10 07:32:42 +02:00
|
|
|
return;
|
|
|
|
}
|
qdev: Use returned bool to check for qdev_realize() etc. failure
Convert
foo(..., &err);
if (err) {
...
}
to
if (!foo(..., &err)) {
...
}
for qdev_realize(), qdev_realize_and_unref(), qbus_realize() and their
wrappers isa_realize_and_unref(), pci_realize_and_unref(),
sysbus_realize(), sysbus_realize_and_unref(), usb_realize_and_unref().
Coccinelle script:
@@
identifier fun = {
isa_realize_and_unref, pci_realize_and_unref, qbus_realize,
qdev_realize, qdev_realize_and_unref, sysbus_realize,
sysbus_realize_and_unref, usb_realize_and_unref
};
expression list args, args2;
typedef Error;
Error *err;
@@
- fun(args, &err, args2);
- if (err)
+ if (!fun(args, &err, args2))
{
...
}
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Nothing to convert there; skipped.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Converted manually.
A few line breaks tidied up manually.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Greg Kurz <groug@kaod.org>
Message-Id: <20200707160613.848843-5-armbru@redhat.com>
2020-07-07 18:05:32 +02:00
|
|
|
if (!qdev_realize(DEVICE(&event_facility->cpu_hotplug),
|
error: Eliminate error_propagate() with Coccinelle, part 1
When all we do with an Error we receive into a local variable is
propagating to somewhere else, we can just as well receive it there
right away. Convert
if (!foo(..., &err)) {
...
error_propagate(errp, err);
...
return ...
}
to
if (!foo(..., errp)) {
...
...
return ...
}
where nothing else needs @err. Coccinelle script:
@rule1 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
binary operator op;
constant c1, c2;
symbol false;
@@
if (
(
- fun(args, &err, args2)
+ fun(args, errp, args2)
|
- !fun(args, &err, args2)
+ !fun(args, errp, args2)
|
- fun(args, &err, args2) op c1
+ fun(args, errp, args2) op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
)
}
@rule2 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
expression var;
binary operator op;
constant c1, c2;
symbol false;
@@
- var = fun(args, &err, args2);
+ var = fun(args, errp, args2);
... when != err
if (
(
var
|
!var
|
var op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
|
return var;
)
}
@depends on rule1 || rule2@
identifier err;
@@
- Error *err = NULL;
... when != err
Not exactly elegant, I'm afraid.
The "when != lbl:" is necessary to avoid transforming
if (fun(args, &err)) {
goto out
}
...
out:
error_propagate(errp, err);
even though other paths to label out still need the error_propagate().
For an actual example, see sclp_realize().
Without the "when strict", Coccinelle transforms vfio_msix_setup(),
incorrectly. I don't know what exactly "when strict" does, only that
it helps here.
The match of return is narrower than what I want, but I can't figure
out how to express "return where the operand doesn't use @err". For
an example where it's too narrow, see vfio_intx_enable().
Silently fails to convert hw/arm/armsse.c, because Coccinelle gets
confused by ARMSSE being used both as typedef and function-like macro
there. Converted manually.
Line breaks tidied up manually. One nested declaration of @local_err
deleted manually. Preexisting unwanted blank line dropped in
hw/riscv/sifive_e.c.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20200707160613.848843-35-armbru@redhat.com>
2020-07-07 18:06:02 +02:00
|
|
|
BUS(&event_facility->sbus), errp)) {
|
2020-06-10 07:32:42 +02:00
|
|
|
qdev_unrealize(DEVICE(&event_facility->quiesce));
|
|
|
|
return;
|
|
|
|
}
|
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
|
|
|
|
2020-06-10 07:32:42 +02:00
|
|
|
dc->realize = realize_event_facility;
|
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;
|
|
|
|
}
|