* [Qemu-devel] [PATCH 0/6v2] s390: several sclp patches
@ 2012-07-13 10:51 Christian Borntraeger
2012-07-13 10:51 ` [Qemu-devel] [PATCH 1/6] s390: Fix error handling and condition code of service call Christian Borntraeger
` (5 more replies)
0 siblings, 6 replies; 14+ messages in thread
From: Christian Borntraeger @ 2012-07-13 10:51 UTC (permalink / raw)
To: Alexander Graf
Cc: Cornelia Huck, Christian Borntraeger, Jens Freimann,
Heinz Graalfs, qemu-devel
This patch-set improve the Service-Call Logical Processor support for s390.
We tried to implement most of the comments that we got from the first patch
review.
We still have code in hw/ since sclp supports features like console etc.
target-s390/op_helper.c now handles the basic checks for the instruction
itself and then passes control to the sclp code, which then parses the
commands.
Patch 1 is a bugfix for the current code, dealing with error and condition
code handling. Patch 2 adds/changes some base SCLP support. Patch 3 adds code
to support the SCLP commands Write Event Mask, Write Event Data, and
Read Event Data. Patch 4 and 5 add code to implement the commands for the
particular SCLP events Signal Quiesce (system_powerdown), and ASCII Console
data.
Patch 6 (s390: make sclp ascii console the default) is currently optional
as it requires a kernel fix in the guest
(http://git.kernel.org/?p=virt/kvm/kvm.git;a=commit;h=cd1834591fe9564720ac4b0193bf1c790fe89f0d
KVM: s390: Perform early event mask processing during boot)
Thanks
Christian Borntraeger (2):
s390: Fix error handling and condition code of service call
s390: make sclp ascii console the default
Heinz Graalfs (4):
s390: sclp base support
s390: sclp event support
s390: sclp signal quiesce support
s390: sclp ascii console support
hw/s390-event-facility.c | 418 ++++++++++++++++++++++++++++++++++++++++++++++
hw/s390-event-facility.h | 107 ++++++++++++
hw/s390-sclp.c | 185 ++++++++++++++++++++
hw/s390-sclp.h | 123 ++++++++++++++
hw/s390-sclpconsole.c | 313 ++++++++++++++++++++++++++++++++++
hw/s390-sclpquiesce.c | 113 +++++++++++++
hw/s390-virtio.c | 4 +-
hw/s390x/Makefile.objs | 1 +
target-s390x/cpu.c | 17 ++
target-s390x/cpu.h | 18 +-
target-s390x/kvm.c | 10 +-
target-s390x/op_helper.c | 68 +++-----
vl.c | 40 +++++
13 files changed, 1351 insertions(+), 66 deletions(-)
create mode 100644 hw/s390-event-facility.c
create mode 100644 hw/s390-event-facility.h
create mode 100644 hw/s390-sclp.c
create mode 100644 hw/s390-sclp.h
create mode 100644 hw/s390-sclpconsole.c
create mode 100644 hw/s390-sclpquiesce.c
--
1.7.10.5
^ permalink raw reply [flat|nested] 14+ messages in thread
* [Qemu-devel] [PATCH 1/6] s390: Fix error handling and condition code of service call
2012-07-13 10:51 [Qemu-devel] [PATCH 0/6v2] s390: several sclp patches Christian Borntraeger
@ 2012-07-13 10:51 ` Christian Borntraeger
2012-07-13 10:52 ` [Qemu-devel] [PATCH 2/6] s390: sclp base support Christian Borntraeger
` (4 subsequent siblings)
5 siblings, 0 replies; 14+ messages in thread
From: Christian Borntraeger @ 2012-07-13 10:51 UTC (permalink / raw)
To: Alexander Graf
Cc: Cornelia Huck, Christian Borntraeger, Jens Freimann,
Heinz Graalfs, qemu-devel
Invalid sccb addresses will cause specification or addressing exception.
Lets add those checks. Furthermore, the good case (cc=0) was incorrect
for KVM, we did not set the CC at all.
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
---
target-s390x/kvm.c | 5 +++--
target-s390x/op_helper.c | 27 ++++++++++++++++++---------
2 files changed, 21 insertions(+), 11 deletions(-)
diff --git a/target-s390x/kvm.c b/target-s390x/kvm.c
index ec08dd0..654f87d 100644
--- a/target-s390x/kvm.c
+++ b/target-s390x/kvm.c
@@ -238,9 +238,10 @@ static int kvm_sclp_service_call(CPUS390XState *env, struct kvm_run *run,
code = env->regs[(ipbh0 & 0xf0) >> 4];
r = sclp_service_call(env, sccb, code);
- if (r) {
- setcc(env, 3);
+ if (r < 0) {
+ enter_pgmcheck(env, -r);
}
+ setcc(env, r);
return 0;
}
diff --git a/target-s390x/op_helper.c b/target-s390x/op_helper.c
index 7b72473..91dd8dc 100644
--- a/target-s390x/op_helper.c
+++ b/target-s390x/op_helper.c
@@ -19,6 +19,8 @@
*/
#include "cpu.h"
+#include "memory.h"
+#include "cputlb.h"
#include "dyngen-exec.h"
#include "host-utils.h"
#include "helper.h"
@@ -2366,6 +2368,9 @@ static void ext_interrupt(CPUS390XState *env, int type, uint32_t param,
cpu_inject_ext(env, type, param, param64);
}
+/*
+ * ret < 0 indicates program check, ret = 0,1,2,3 -> cc
+ */
int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code)
{
int r = 0;
@@ -2375,10 +2380,12 @@ int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code)
printf("sclp(0x%x, 0x%" PRIx64 ")\n", sccb, code);
#endif
+ /* basic checks */
+ if (!memory_region_is_ram(phys_page_find(sccb >> TARGET_PAGE_BITS)->mr)) {
+ return -PGM_ADDRESSING;
+ }
if (sccb & ~0x7ffffff8ul) {
- fprintf(stderr, "KVM: invalid sccb address 0x%x\n", sccb);
- r = -1;
- goto out;
+ return -PGM_SPECIFICATION;
}
switch(code) {
@@ -2405,22 +2412,24 @@ int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code)
#ifdef DEBUG_HELPER
printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
#endif
- r = -1;
+ r = 3;
break;
}
-out:
return r;
}
/* SCLP service call */
uint32_t HELPER(servc)(uint32_t r1, uint64_t r2)
{
- if (sclp_service_call(env, r1, r2)) {
- return 3;
- }
+ int r;
- return 0;
+ r = sclp_service_call(env, r1, r2);
+ if (r < 0) {
+ program_interrupt(env, -r, 4);
+ return 0;
+ }
+ return r;
}
/* DIAG */
--
1.7.10.5
^ permalink raw reply related [flat|nested] 14+ messages in thread
* [Qemu-devel] [PATCH 2/6] s390: sclp base support
2012-07-13 10:51 [Qemu-devel] [PATCH 0/6v2] s390: several sclp patches Christian Borntraeger
2012-07-13 10:51 ` [Qemu-devel] [PATCH 1/6] s390: Fix error handling and condition code of service call Christian Borntraeger
@ 2012-07-13 10:52 ` Christian Borntraeger
2012-07-13 15:08 ` Blue Swirl
2012-07-20 14:06 ` Andreas Färber
2012-07-13 10:52 ` [Qemu-devel] [PATCH 3/6] s390: sclp event support Christian Borntraeger
` (3 subsequent siblings)
5 siblings, 2 replies; 14+ messages in thread
From: Christian Borntraeger @ 2012-07-13 10:52 UTC (permalink / raw)
To: Alexander Graf
Cc: Cornelia Huck, Christian Borntraeger, Jens Freimann,
Heinz Graalfs, qemu-devel
From: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
This adds a more generic infrastructure for handling Service-Call
requests on s390. Currently we only support a small subset of Read
SCP Info directly in target-s390x. This patch provides the base
infrastructure for supporting more commands and moves Read SCP
Info.
In the future we could add additional commands for hotplug, call
home and event handling.
Signed-off-by: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
---
hw/s390-sclp.c | 148 ++++++++++++++++++++++++++++++++++++++++++++++
hw/s390-sclp.h | 80 +++++++++++++++++++++++++
hw/s390-virtio.c | 3 +
hw/s390x/Makefile.objs | 1 +
target-s390x/cpu.c | 17 ++++++
target-s390x/cpu.h | 18 ++----
target-s390x/kvm.c | 5 +-
target-s390x/op_helper.c | 45 ++------------
8 files changed, 261 insertions(+), 56 deletions(-)
create mode 100644 hw/s390-sclp.c
create mode 100644 hw/s390-sclp.h
diff --git a/hw/s390-sclp.c b/hw/s390-sclp.c
new file mode 100644
index 0000000..74a3e66
--- /dev/null
+++ b/hw/s390-sclp.c
@@ -0,0 +1,148 @@
+/*
+ * SCLP Support
+ *
+ * Copyright IBM, Corp. 2007, 2012
+ *
+ * Authors:
+ * Christian Borntraeger <borntraeger@de.ibm.com>
+ * Heinz Graalfs <graalfs@linux.vnet.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2. See
+ * the COPYING file in the top-level directory.
+ *
+ */
+
+#include "cpu.h"
+#include "kvm.h"
+#include "sysbus.h"
+
+#include "s390-sclp.h"
+
+/* Provide information about the configuration, CPUs and storage */
+static int read_SCP_info(SCCB *sccb)
+{
+ ReadInfo *read_info = (ReadInfo *) sccb;
+ int shift = 0;
+
+ while ((ram_size >> (20 + shift)) > 65535) {
+ shift++;
+ }
+ read_info->rnmax = cpu_to_be16(ram_size >> (20 + shift));
+ read_info->rnsize = 1 << shift;
+ sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
+
+ return 0;
+}
+
+static int sclp_execute(SCCB *sccb, uint64_t code)
+{
+ int r = 0;
+
+ switch (code) {
+ case SCLP_CMDW_READ_SCP_INFO:
+ case SCLP_CMDW_READ_SCP_INFO_FORCED:
+ r = read_SCP_info(sccb);
+ break;
+ default:
+#ifdef DEBUG_HELPER
+ printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
+#endif
+ sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
+ break;
+ }
+ return r;
+}
+
+int do_sclp_service_call(uint32_t sccb, uint64_t code)
+{
+ int r = 0;
+ SCCB work_sccb;
+
+ target_phys_addr_t sccb_len = sizeof(SCCB);
+
+ /*
+ * we want to work on a private copy of the sccb, to prevent guests
+ * from playing dirty tricks by modifying the memory content after
+ * the host has checked the values
+ */
+ cpu_physical_memory_read(sccb, &work_sccb, sccb_len);
+
+ /* Valid sccb sizes */
+ if (be16_to_cpu(work_sccb.h.length) < 8 ||
+ be16_to_cpu(work_sccb.h.length) > 4096) {
+ r = -PGM_SPECIFICATION;
+ goto out;
+ }
+
+ r = sclp_execute((SCCB *)&work_sccb, code);
+
+ cpu_physical_memory_write(sccb, &work_sccb,
+ be16_to_cpu(work_sccb.h.length));
+ if (!r) {
+ sclp_service_interrupt(sccb);
+ }
+
+out:
+ return r;
+}
+
+void sclp_service_interrupt(uint32_t sccb)
+{
+ if (!sccb) {
+ return;
+ }
+ s390_sclp_extint(sccb & ~3);
+}
+
+/* qemu object creation and initialization functions */
+
+#define S390_SCLP_BUS(obj) OBJECT_CHECK(SCLPS390Bus, (obj), TYPE_S390_SCLP_BUS)
+static const TypeInfo s390_sclp_bus_info = {
+ .name = TYPE_S390_SCLP_BUS,
+ .parent = TYPE_BUS,
+ .instance_size = sizeof(SCLPS390Bus),
+ };
+
+SCLPS390Bus *s390_sclp_bus_init(void)
+{
+ SCLPS390Bus *bus;
+ BusState *bus_state;
+ DeviceState *dev;
+
+ dev = qdev_create(NULL, "s390-sclp-bridge");
+ qdev_init_nofail(dev);
+
+ bus_state = qbus_create(TYPE_S390_SCLP_BUS, dev, "s390-sclp-bus");
+ bus_state->allow_hotplug = 0;
+
+ bus = DO_UPCAST(SCLPS390Bus, bus, bus_state);
+ return bus;
+}
+
+static int s390_sclp_bridge_init(SysBusDevice *dev)
+{
+ return 0;
+}
+
+static void s390_sclp_bridge_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
+
+ k->init = s390_sclp_bridge_init;
+ dc->no_user = 1;
+}
+
+static TypeInfo s390_sclp_bridge_info = {
+ .name = "s390-sclp-bridge",
+ .parent = TYPE_SYS_BUS_DEVICE,
+ .instance_size = sizeof(SysBusDevice),
+ .class_init = s390_sclp_bridge_class_init,
+};
+
+static void s390_sclp_register_types(void)
+{
+ type_register_static(&s390_sclp_bridge_info);
+ type_register_static(&s390_sclp_bus_info);
+}
+type_init(s390_sclp_register_types)
diff --git a/hw/s390-sclp.h b/hw/s390-sclp.h
new file mode 100644
index 0000000..f7bf140
--- /dev/null
+++ b/hw/s390-sclp.h
@@ -0,0 +1,80 @@
+/*
+ * SCLP Support
+ *
+ * Copyright IBM, Corp. 2007, 2012
+ *
+ * Authors:
+ * Christian Borntraeger <borntraeger@de.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2. See
+ * the COPYING file in the top-level directory.
+ *
+ */
+
+#ifndef _QEMU_S390_SCLP_H
+#define _QEMU_S390_SCLP_H
+
+#include "qdev.h"
+
+/* SCLP command codes */
+#define SCLP_CMDW_READ_SCP_INFO 0x00020001
+#define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
+
+/* SCLP response codes */
+#define SCLP_RC_NORMAL_READ_COMPLETION 0x0010
+#define SCLP_RC_INVALID_SCLP_COMMAND 0x01f0
+
+/* Service Call Control Block (SCCB) and its elements */
+
+#define SCCB_SIZE 4096
+
+/*
+ * Normally packed structures are not the right thing to do, since all code
+ * must take care of endianess. We cant use ldl_phys and friends for two
+ * reasons, though:
+ * - some of the embedded structures below the SCCB can appear multiple times
+ * at different locations, so there is no fixed offset
+ * - we work on a private copy of the SCCB, since there are several length
+ * fields, that would cause a security nightmare if we allow the guest to
+ * alter the structure while we parse it. We cannot use ldl_p and friends
+ * either without doing pointer arithmetics
+ * So we have to double check that all users of sclp data structures use the
+ * right endianess wrappers.
+ */
+typedef struct SCCBHeader {
+ uint16_t length;
+ uint8_t function_code;
+ uint8_t control_mask[3];
+ uint16_t response_code;
+} __attribute__((packed)) SCCBHeader;
+
+#define SCCB_DATA_LEN (SCCB_SIZE - sizeof(SCCBHeader))
+
+typedef struct ReadInfo {
+ SCCBHeader h;
+ uint16_t rnmax;
+ uint8_t rnsize;
+} __attribute__((packed)) ReadInfo;
+
+typedef struct SCCB {
+ SCCBHeader h;
+ char data[SCCB_DATA_LEN];
+ } __attribute__((packed)) SCCB;
+
+#define TYPE_S390_SCLP_BUS "s390-sclp-bus"
+
+typedef struct S390SCLPDevice {
+ DeviceState qdev;
+} S390SCLPDevice;
+
+typedef struct SCLPS390Bus {
+ BusState bus;
+} SCLPS390Bus;
+
+extern SCLPS390Bus *sclp_bus;
+
+SCLPS390Bus *s390_sclp_bus_init(void);
+
+void sclp_service_interrupt(uint32_t sccb);
+
+#endif
diff --git a/hw/s390-virtio.c b/hw/s390-virtio.c
index 47eed35..577fcee 100644
--- a/hw/s390-virtio.c
+++ b/hw/s390-virtio.c
@@ -32,6 +32,7 @@
#include "exec-memory.h"
#include "hw/s390-virtio-bus.h"
+#include "hw/s390-sclp.h"
//#define DEBUG_S390
@@ -61,6 +62,7 @@
#define MAX_BLK_DEVS 10
static VirtIOS390Bus *s390_bus;
+SCLPS390Bus *sclp_bus;
static S390CPU **ipi_states;
S390CPU *s390_cpu_addr2state(uint16_t cpu_addr)
@@ -183,6 +185,7 @@ static void s390_init(ram_addr_t my_ram_size,
/* get a BUS */
s390_bus = s390_virtio_bus_init(&my_ram_size);
+ sclp_bus = s390_sclp_bus_init();
/* allocate RAM */
memory_region_init_ram(ram, "s390.ram", my_ram_size);
diff --git a/hw/s390x/Makefile.objs b/hw/s390x/Makefile.objs
index dcdcac8..b2d577b 100644
--- a/hw/s390x/Makefile.objs
+++ b/hw/s390x/Makefile.objs
@@ -1,3 +1,4 @@
obj-y = s390-virtio-bus.o s390-virtio.o
+obj-y += s390-sclp.o
obj-y := $(addprefix ../,$(obj-y))
diff --git a/target-s390x/cpu.c b/target-s390x/cpu.c
index 619b202..8900872 100644
--- a/target-s390x/cpu.c
+++ b/target-s390x/cpu.c
@@ -21,9 +21,26 @@
*/
#include "cpu.h"
+#include "kvm.h"
#include "qemu-common.h"
#include "qemu-timer.h"
+/* service interrupts are floating therefore we must not pass an cpustate */
+void s390_sclp_extint(uint32_t parm)
+{
+ S390CPU *dummy_cpu = s390_cpu_addr2state(0);
+ CPUS390XState *env = &dummy_cpu->env;
+
+ if (kvm_enabled()) {
+#ifdef CONFIG_KVM
+ kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE, parm, 0, 1);
+#endif
+ } else {
+ env->psw.addr += 4;
+ cpu_inject_ext(env, EXT_SERVICE, parm, 0);
+ }
+}
+
/* CPUClass::reset() */
static void s390_cpu_reset(CPUState *s)
diff --git a/target-s390x/cpu.h b/target-s390x/cpu.h
index c30ac3a..abdd838 100644
--- a/target-s390x/cpu.h
+++ b/target-s390x/cpu.h
@@ -294,6 +294,7 @@ void s390x_tod_timer(void *opaque);
void s390x_cpu_timer(void *opaque);
int s390_virtio_hypercall(CPUS390XState *env, uint64_t mem, uint64_t hypercall);
+int do_sclp_service_call(uint32_t sccb, uint64_t code);
#ifdef CONFIG_KVM
void kvm_s390_interrupt(CPUS390XState *env, int type, uint32_t code);
@@ -315,11 +316,15 @@ static inline void kvm_s390_interrupt_internal(CPUS390XState *env, int type,
int vm)
{
}
+
#endif
S390CPU *s390_cpu_addr2state(uint16_t cpu_addr);
void s390_add_running_cpu(CPUS390XState *env);
unsigned s390_del_running_cpu(CPUS390XState *env);
+/* service interrupts are floating therefore we must not pass an cpustate */
+void s390_sclp_extint(uint32_t parm);
+
/* from s390-virtio-bus */
extern const target_phys_addr_t virtio_size;
@@ -593,17 +598,6 @@ static inline const char *cc_name(int cc_op)
return cc_names[cc_op];
}
-/* SCLP PV interface defines */
-#define SCLP_CMDW_READ_SCP_INFO 0x00020001
-#define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
-
-#define SCP_LENGTH 0x00
-#define SCP_FUNCTION_CODE 0x02
-#define SCP_CONTROL_MASK 0x03
-#define SCP_RESPONSE_CODE 0x06
-#define SCP_MEM_CODE 0x08
-#define SCP_INCREMENT 0x0a
-
typedef struct LowCore
{
/* prefix area: defined by architecture */
@@ -952,7 +946,7 @@ static inline void ebcdic_put(uint8_t *p, const char *ascii, int len)
void load_psw(CPUS390XState *env, uint64_t mask, uint64_t addr);
int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
target_ulong *raddr, int *flags);
-int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code);
+int sclp_service_call(uint32_t sccb, uint64_t code);
uint32_t calc_cc(CPUS390XState *env, uint32_t cc_op, uint64_t src, uint64_t dst,
uint64_t vr);
diff --git a/target-s390x/kvm.c b/target-s390x/kvm.c
index 654f87d..68c4f3e 100644
--- a/target-s390x/kvm.c
+++ b/target-s390x/kvm.c
@@ -60,9 +60,6 @@
#define SIGP_STORE_STATUS_ADDR 0x0e
#define SIGP_SET_ARCH 0x12
-#define SCLP_CMDW_READ_SCP_INFO 0x00020001
-#define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
-
const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
KVM_CAP_LAST_INFO
};
@@ -237,7 +234,7 @@ static int kvm_sclp_service_call(CPUS390XState *env, struct kvm_run *run,
sccb = env->regs[ipbh0 & 0xf];
code = env->regs[(ipbh0 & 0xf0) >> 4];
- r = sclp_service_call(env, sccb, code);
+ r = sclp_service_call(sccb, code);
if (r < 0) {
enter_pgmcheck(env, -r);
}
diff --git a/target-s390x/op_helper.c b/target-s390x/op_helper.c
index 91dd8dc..e7bb980 100644
--- a/target-s390x/op_helper.c
+++ b/target-s390x/op_helper.c
@@ -2362,20 +2362,12 @@ static void program_interrupt(CPUS390XState *env, uint32_t code, int ilc)
}
}
-static void ext_interrupt(CPUS390XState *env, int type, uint32_t param,
- uint64_t param64)
-{
- cpu_inject_ext(env, type, param, param64);
-}
-
/*
+ * we handle here the part that belongs to the cpu, e.g. program checks
* ret < 0 indicates program check, ret = 0,1,2,3 -> cc
*/
-int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code)
+int sclp_service_call(uint32_t sccb, uint64_t code)
{
- int r = 0;
- int shift = 0;
-
#ifdef DEBUG_HELPER
printf("sclp(0x%x, 0x%" PRIx64 ")\n", sccb, code);
#endif
@@ -2388,35 +2380,8 @@ int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code)
return -PGM_SPECIFICATION;
}
- switch(code) {
- case SCLP_CMDW_READ_SCP_INFO:
- case SCLP_CMDW_READ_SCP_INFO_FORCED:
- while ((ram_size >> (20 + shift)) > 65535) {
- shift++;
- }
- stw_phys(sccb + SCP_MEM_CODE, ram_size >> (20 + shift));
- stb_phys(sccb + SCP_INCREMENT, 1 << shift);
- stw_phys(sccb + SCP_RESPONSE_CODE, 0x10);
-
- if (kvm_enabled()) {
-#ifdef CONFIG_KVM
- kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE,
- sccb & ~3, 0, 1);
-#endif
- } else {
- env->psw.addr += 4;
- ext_interrupt(env, EXT_SERVICE, sccb & ~3, 0);
- }
- break;
- default:
-#ifdef DEBUG_HELPER
- printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
-#endif
- r = 3;
- break;
- }
-
- return r;
+ /* the complex part is handled by external components */
+ return do_sclp_service_call(sccb, code);
}
/* SCLP service call */
@@ -2424,7 +2389,7 @@ uint32_t HELPER(servc)(uint32_t r1, uint64_t r2)
{
int r;
- r = sclp_service_call(env, r1, r2);
+ r = sclp_service_call(r1, r2);
if (r < 0) {
program_interrupt(env, -r, 4);
return 0;
--
1.7.10.5
^ permalink raw reply related [flat|nested] 14+ messages in thread
* [Qemu-devel] [PATCH 3/6] s390: sclp event support
2012-07-13 10:51 [Qemu-devel] [PATCH 0/6v2] s390: several sclp patches Christian Borntraeger
2012-07-13 10:51 ` [Qemu-devel] [PATCH 1/6] s390: Fix error handling and condition code of service call Christian Borntraeger
2012-07-13 10:52 ` [Qemu-devel] [PATCH 2/6] s390: sclp base support Christian Borntraeger
@ 2012-07-13 10:52 ` Christian Borntraeger
2012-07-13 15:10 ` Blue Swirl
2012-07-13 10:52 ` [Qemu-devel] [PATCH 4/6] s390: sclp signal quiesce support Christian Borntraeger
` (2 subsequent siblings)
5 siblings, 1 reply; 14+ messages in thread
From: Christian Borntraeger @ 2012-07-13 10:52 UTC (permalink / raw)
To: Alexander Graf
Cc: Cornelia Huck, Christian Borntraeger, Jens Freimann,
Heinz Graalfs, qemu-devel
From: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
Several SCLP features are considered to be events. Those events don't
provide SCLP commands on their own, instead they are all based on
Read Event Data, Write Event Data, Write Event Mask and the service
interrupt. Follow-on patches will provide SCLP's Signal Quiesce (via
system_powerdown) and the ASCII console.
Further down the road the sclp line mode console and configuration
change events (e.g. cpu hotplug) can be implemented.
Signed-off-by: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
---
hw/s390-event-facility.c | 412 ++++++++++++++++++++++++++++++++++++++++++++++
hw/s390-event-facility.h | 107 ++++++++++++
hw/s390-sclp.c | 49 +++++-
hw/s390-sclp.h | 43 +++++
hw/s390x/Makefile.objs | 2 +-
5 files changed, 606 insertions(+), 7 deletions(-)
create mode 100644 hw/s390-event-facility.c
create mode 100644 hw/s390-event-facility.h
diff --git a/hw/s390-event-facility.c b/hw/s390-event-facility.c
new file mode 100644
index 0000000..42ac102
--- /dev/null
+++ b/hw/s390-event-facility.c
@@ -0,0 +1,412 @@
+/*
+ * SCLP
+ * Event Facility
+ * handles SCLP event types
+ * - Signal Quiesce - system power down
+ * - ASCII Console Data - VT220 read and write
+ *
+ * Copyright IBM, Corp. 2007, 2012
+ *
+ * Authors:
+ * Heinz Graalfs <graalfs@de.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2. See
+ * the COPYING file in the top-level directory.
+ *
+ */
+
+#include "monitor.h"
+#include "sysemu.h"
+
+#include "s390-sclp.h"
+#include "s390-event-facility.h"
+
+typedef struct EventTypes {
+ BusState qbus;
+ SCLPEventFacility *event_facility;
+} EventTypes;
+
+struct SCLPEventFacility {
+ EventTypes sbus;
+ DeviceState *qdev;
+ /* guest' receive mask */
+ unsigned int receive_mask;
+};
+
+/* return true if any child has event pending set */
+static bool event_pending(void)
+{
+ BusChild *kid;
+ SCLPEvent *event;
+
+ SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
+
+ QTAILQ_FOREACH(kid, &event_facility->sbus.qbus.children, sibling) {
+ DeviceState *qdev = kid->child;
+ event = DO_UPCAST(SCLPEvent, qdev, qdev);
+ lock(event);
+ if (event->event_pending) {
+ unlock(event);
+ return true;
+ }
+ unlock(event);
+ }
+ return false;
+}
+
+static unsigned int get_host_send_mask(void)
+{
+ unsigned int mask;
+ BusChild *kid;
+ SCLPEventClass *child;
+ SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
+
+ mask = 0;
+
+ QTAILQ_FOREACH(kid, &event_facility->sbus.qbus.children, sibling) {
+ DeviceState *qdev = kid->child;
+ child = SCLP_EVENT_GET_CLASS((SCLPEvent *) qdev);
+ mask |= child->get_send_mask();
+ }
+ return mask;
+}
+
+static unsigned int get_host_receive_mask(void)
+{
+ unsigned int mask;
+ BusChild *kid;
+ SCLPEventClass *child;
+ SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
+
+ mask = 0;
+
+ QTAILQ_FOREACH(kid, &event_facility->sbus.qbus.children, sibling) {
+ DeviceState *qdev = kid->child;
+ child = SCLP_EVENT_GET_CLASS((SCLPEvent *) qdev);
+ mask |= child->get_receive_mask();
+ }
+ return mask;
+}
+
+static inline void set_guest_receive_mask(unsigned int mask)
+{
+ SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
+
+ event_facility->receive_mask = mask;
+}
+
+static inline unsigned int get_guest_receive_mask(void)
+{
+ SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
+
+ return event_facility->receive_mask;
+}
+
+static int check_sccb_events(SCCB *sccb)
+{
+ int slen;
+ unsigned elen = 0;
+ EventBufferHeader *event;
+ WriteEventData *wed = (WriteEventData *) sccb;
+
+ event = (EventBufferHeader *) &wed->ebh;
+ for (slen = be16_to_cpu(sccb->h.length) - sizeof(sccb->h);
+ slen > 0; slen -= elen) {
+ elen = be16_to_cpu(event->length);
+ if (elen < sizeof(*event) || elen > slen) {
+ sccb->h.response_code =
+ cpu_to_be16(SCLP_RC_EVENT_BUFFER_SYNTAX_ERROR);
+ return 1;
+ }
+ event = (void *) event + elen;
+ }
+ if (slen) {
+ sccb->h.response_code = cpu_to_be16(SCLP_RC_INCONSISTENT_LENGTHS);
+ return 1;
+ }
+ return 0;
+}
+
+static void handle_sccb_write_events(SCCB *sccb)
+{
+ int slen;
+ unsigned elen = 0;
+ EventBufferHeader *event_buf;
+ BusChild *kid;
+ SCLPEvent *event;
+ SCLPEventClass *ec;
+
+ WriteEventData *wed = (WriteEventData *) sccb;
+
+ SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
+
+ event_buf = &wed->ebh;
+
+ /* loop over all contained event buffers */
+ for (slen = be16_to_cpu(sccb->h.length) - sizeof(sccb->h);
+ 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 (sccb->h.response_code !=
+ cpu_to_be16(SCLP_RC_NORMAL_COMPLETION)) {
+ event_buf->flags &= ~(SCLP_EVENT_BUFFER_ACCEPTED);
+ } else {
+ sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION);
+ QTAILQ_FOREACH(kid, &event_facility->sbus.qbus.children, sibling) {
+ DeviceState *qdev = kid->child;
+ event = (SCLPEvent *) qdev;
+ ec = SCLP_EVENT_GET_CLASS(event);
+
+ if (ec->write_event_data &&
+ ec->event_type() == event_buf->type) {
+ sccb->h.response_code = cpu_to_be16(
+ ec->write_event_data(event, event_buf));
+ break;
+ }
+ }
+ }
+ event_buf = (void *) event_buf + elen;
+ }
+}
+
+static int write_event_data(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 check the sum of all events */
+ if (check_sccb_events(sccb)) {
+ goto out;
+ }
+ /* then execute */
+ sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
+ handle_sccb_write_events(sccb);
+
+out:
+ return 0;
+}
+
+static void handle_sccb_read_events(SCCB *sccb, unsigned int mask)
+{
+ int slen;
+ unsigned elen = 0;
+ BusChild *kid;
+ SCLPEvent *event;
+ SCLPEventClass *ec;
+ EventBufferHeader *event_buf;
+ ReadEventData *red = (ReadEventData *) sccb;
+
+ SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
+
+ event_buf = &red->ebh;
+ event_buf->length = 0;
+ slen = sizeof(sccb->data);
+ QTAILQ_FOREACH(kid, &event_facility->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)) {
+ sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
+ }
+ }
+ elen = be16_to_cpu(event_buf->length);
+ event_buf = (void *) event_buf + elen;
+ }
+
+ if (sccb->h.control_mask[2] & SCLP_VARIABLE_LENGTH_RESPONSE) {
+ sccb->h.control_mask[2] &= ~SCLP_VARIABLE_LENGTH_RESPONSE;
+ sccb->h.length = cpu_to_be16(SCCB_SIZE - slen);
+ }
+}
+
+static int read_event_data(SCCB *sccb)
+{
+ unsigned int sclp_active_selection_mask;
+ unsigned int sclp_cp_receive_mask;
+
+ ReadEventData *red = (ReadEventData *) sccb;
+
+ if (be16_to_cpu(sccb->h.length) != SCCB_SIZE) {
+ sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
+ goto out;
+ }
+
+ sclp_cp_receive_mask = get_guest_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:
+ if (!(sclp_cp_receive_mask & be32_to_cpu(red->mask))) {
+ sccb->h.response_code =
+ cpu_to_be16(SCLP_RC_INVALID_SELECTION_MASK);
+ goto out;
+ }
+ sclp_active_selection_mask = be32_to_cpu(red->mask);
+ break;
+ default:
+ sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION);
+ goto out;
+ }
+
+ sccb->h.response_code = cpu_to_be16(SCLP_RC_NO_EVENT_BUFFERS_STORED);
+ handle_sccb_read_events(sccb, sclp_active_selection_mask);
+
+out:
+ return 0;
+}
+
+static int write_event_mask(SCCB *sccb)
+{
+ WriteEventMask *we_mask = (WriteEventMask *) sccb;
+
+ /* Attention: We assume that Linux uses 4-byte masks, what it actually
+ does. Architecture allows for masks of variable size, though */
+ if (be16_to_cpu(we_mask->mask_length) != 4) {
+ sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_MASK_LENGTH);
+ goto out;
+ }
+
+ /* keep track of the guest's capability masks */
+ set_guest_receive_mask(be32_to_cpu(we_mask->cp_receive_mask));
+
+ /* return the SCLP's capability masks to the guest */
+ we_mask->send_mask = cpu_to_be32(get_host_send_mask());
+ we_mask->receive_mask = cpu_to_be32(get_host_receive_mask());
+
+ sccb->h.response_code = cpu_to_be32(SCLP_RC_NORMAL_COMPLETION);
+
+out:
+ return 0;
+}
+
+/* qemu object creation and initialization functions */
+
+#define TYPE_SCLP_EVENTS_BUS "s390-sclp-events-bus"
+#define SCLP_EVENTS_BUS(obj) OBJECT_CHECK(SCLPS390Bus, (obj),\
+ TYPE_SCLP_EVENTS_BUS)
+
+static void sclp_events_bus_class_init(ObjectClass *klass, void *data)
+{
+}
+
+static const TypeInfo s390_sclp_events_bus_info = {
+ .name = TYPE_SCLP_EVENTS_BUS,
+ .parent = TYPE_BUS,
+ .instance_size = sizeof(SCLPS390Bus),
+ .class_init = sclp_events_bus_class_init,
+};
+
+static int command_handler(SCCB *sccb, uint64_t code)
+{
+ int r = 0;
+
+ switch (code) {
+ case SCLP_CMD_READ_EVENT_DATA:
+ r = read_event_data(sccb);
+ break;
+ case SCLP_CMD_WRITE_EVENT_DATA:
+ r = write_event_data(sccb);
+ break;
+ case SCLP_CMD_WRITE_EVENT_MASK:
+ r = write_event_mask(sccb);
+ break;
+ default:
+#ifdef DEBUG_HELPER
+ printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
+#endif
+ sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
+ break;
+ }
+ return r;
+}
+
+static int init_event_facility(S390SCLPDevice *sdev)
+{
+ SCLPEventFacility *event_facility;
+
+ event_facility = g_malloc0(sizeof(SCLPEventFacility));
+ sdev->instance = event_facility;
+ sdev->sclp_command_handler = command_handler;
+ sdev->event_pending = event_pending;
+
+ /* Spawn a new sclp-events facility */
+ qbus_create_inplace(&event_facility->sbus.qbus,
+ TYPE_SCLP_EVENTS_BUS, (DeviceState *)sdev, NULL);
+ event_facility->sbus.qbus.allow_hotplug = 0;
+ event_facility->sbus.event_facility = event_facility;
+ event_facility->qdev = (DeviceState *) sdev;
+
+
+ return 0;
+}
+
+static void init_event_facility_class(ObjectClass *klass, void *data)
+{
+ S390SCLPDeviceClass *k = SCLP_S390_DEVICE_CLASS(klass);
+
+ k->init = init_event_facility;
+}
+
+static TypeInfo s390_sclp_event_facility_info = {
+ .name = "s390-sclp-event-facility",
+ .parent = TYPE_DEVICE_S390_SCLP,
+ .instance_size = sizeof(S390SCLPDevice),
+ .class_init = init_event_facility_class,
+};
+
+static int event_qdev_init(DeviceState *qdev)
+{
+ SCLPEvent *event = DO_UPCAST(SCLPEvent, qdev, qdev);
+ SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event);
+
+ return child->init(event);
+}
+
+static int event_qdev_exit(DeviceState *qdev)
+{
+ SCLPEvent *event = DO_UPCAST(SCLPEvent, qdev, qdev);
+ SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event);
+ if (child->exit) {
+ child->exit(event);
+ }
+ return 0;
+}
+
+static void event_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+
+ dc->bus_type = TYPE_SCLP_EVENTS_BUS;
+ dc->unplug = qdev_simple_unplug_cb;
+ dc->init = event_qdev_init;
+ dc->exit = event_qdev_exit;
+}
+
+static TypeInfo s390_sclp_event_type_info = {
+ .name = TYPE_SCLP_EVENT,
+ .parent = TYPE_DEVICE,
+ .instance_size = sizeof(SCLPEvent),
+ .class_init = event_class_init,
+ .class_size = sizeof(SCLPEventClass),
+ .abstract = true,
+};
+
+static void register_types(void)
+{
+ type_register_static(&s390_sclp_events_bus_info);
+ type_register_static(&s390_sclp_event_facility_info);
+ type_register_static(&s390_sclp_event_type_info);
+}
+type_init(register_types)
diff --git a/hw/s390-event-facility.h b/hw/s390-event-facility.h
new file mode 100644
index 0000000..938fb4b
--- /dev/null
+++ b/hw/s390-event-facility.h
@@ -0,0 +1,107 @@
+/*
+ * SCLP
+ * Event Facility definitions
+ *
+ * Copyright IBM, Corp. 2007, 2012
+ *
+ * Authors:
+ * Heinz Graalfs <graalfs@de.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2. See
+ * the COPYING file in the top-level directory.
+ *
+ */
+
+#ifndef _QEMU_S390_SCLP_EVENT_FACILITY_H
+#define _QEMU_S390_SCLP_EVENT_FACILITY_H
+
+#include "qdev.h"
+#include "qemu-thread.h"
+
+/* SCLP event types */
+#define SCLP_EVENT_ASCII_CONSOLE_DATA 0x1a
+#define SCLP_EVENT_SIGNAL_QUIESCE 0x1d
+
+/* SCLP event masks */
+#define SCLP_EVENT_MASK_SIGNAL_QUIESCE 0x00000008
+#define SCLP_EVENT_MASK_MSG_ASCII 0x00000040
+
+#define SCLP_UNCONDITIONAL_READ 0x00
+#define SCLP_SELECTIVE_READ 0x01
+
+#define TYPE_SCLP_EVENT "s390-sclp-event-type"
+#define SCLP_EVENT(obj) \
+ OBJECT_CHECK(SCLPEvent, (obj), TYPE_SCLP_EVENT)
+#define SCLP_EVENT_CLASS(klass) \
+ OBJECT_CLASS_CHECK(SCLPEventClass, (klass), TYPE_SCLP_EVENT)
+#define SCLP_EVENT_GET_CLASS(obj) \
+ OBJECT_GET_CLASS(SCLPEventClass, (obj), TYPE_SCLP_EVENT)
+
+typedef struct WriteEventMask {
+ SCCBHeader h;
+ uint16_t _reserved;
+ uint16_t mask_length;
+ uint32_t cp_receive_mask;
+ uint32_t cp_send_mask;
+ uint32_t send_mask;
+ uint32_t receive_mask;
+} __attribute__((packed)) WriteEventMask;
+
+typedef struct EventBufferHeader {
+ uint16_t length;
+ uint8_t type;
+ uint8_t flags;
+ uint16_t _reserved;
+} __attribute__((packed)) EventBufferHeader;
+
+typedef struct WriteEventData {
+ SCCBHeader h;
+ EventBufferHeader ebh;
+} __attribute__((packed)) WriteEventData;
+
+typedef struct ReadEventData {
+ SCCBHeader h;
+ EventBufferHeader ebh;
+ uint32_t mask;
+} __attribute__((packed)) ReadEventData;
+
+typedef struct SCLPEvent {
+ DeviceState qdev;
+ QemuMutex lock;
+ bool event_pending;
+ uint32_t event_type;
+ char *name;
+} SCLPEvent;
+
+typedef struct SCLPEventClass {
+ DeviceClass parent_class;
+ int (*init)(SCLPEvent *event);
+ int (*exit)(SCLPEvent *event);
+
+ /* get SCLP's send mask */
+ unsigned int (*get_send_mask)(void);
+
+ /* get SCLP's receive mask */
+ unsigned int (*get_receive_mask)(void);
+
+ int (*read_event_data)(SCLPEvent *event, EventBufferHeader *evt_buf_hdr,
+ int *slen);
+
+ int (*write_event_data)(SCLPEvent *event, EventBufferHeader *evt_buf_hdr);
+
+ /* returns the supported event type */
+ int (*event_type)(void);
+
+} SCLPEventClass;
+
+static inline void lock(SCLPEvent *event)
+{
+ qemu_mutex_lock(&event->lock);
+}
+
+static inline void unlock(SCLPEvent *event)
+{
+ qemu_mutex_unlock(&event->lock);
+}
+
+#endif
diff --git a/hw/s390-sclp.c b/hw/s390-sclp.c
index 74a3e66..4ee04b1 100644
--- a/hw/s390-sclp.c
+++ b/hw/s390-sclp.c
@@ -44,10 +44,7 @@ static int sclp_execute(SCCB *sccb, uint64_t code)
r = read_SCP_info(sccb);
break;
default:
-#ifdef DEBUG_HELPER
- printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
-#endif
- sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
+ r = sclp_bus->event_facility->sclp_command_handler(sccb, code);
break;
}
return r;
@@ -88,10 +85,12 @@ out:
void sclp_service_interrupt(uint32_t sccb)
{
- if (!sccb) {
+ int event_pending = sclp_bus->event_facility->event_pending();
+
+ if (!event_pending && !sccb) {
return;
}
- s390_sclp_extint(sccb & ~3);
+ s390_sclp_extint((sccb & ~3) + event_pending);
}
/* qemu object creation and initialization functions */
@@ -115,6 +114,9 @@ SCLPS390Bus *s390_sclp_bus_init(void)
bus_state = qbus_create(TYPE_S390_SCLP_BUS, dev, "s390-sclp-bus");
bus_state->allow_hotplug = 0;
+ dev = qdev_create(bus_state, "s390-sclp-event-facility");
+ qdev_init_nofail(dev);
+
bus = DO_UPCAST(SCLPS390Bus, bus, bus_state);
return bus;
}
@@ -140,9 +142,44 @@ static TypeInfo s390_sclp_bridge_info = {
.class_init = s390_sclp_bridge_class_init,
};
+static int s390_sclp_busdev_init(DeviceState *dev)
+{
+ int r;
+ S390SCLPDevice *sdev = (S390SCLPDevice *)dev;
+ S390SCLPDeviceClass *sclp = SCLP_S390_DEVICE_GET_CLASS(dev);
+ SCLPS390Bus *bus = DO_UPCAST(SCLPS390Bus, bus, sdev->qdev.parent_bus);
+
+ r = sclp->init(sdev);
+ if (!r) {
+ assert(sdev->event_pending);
+ assert(sdev->sclp_command_handler);
+ }
+ bus->event_facility = sdev;
+
+ return r;
+}
+
+static void s390_sclp_device_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+
+ dc->init = s390_sclp_busdev_init;
+ dc->bus_type = TYPE_S390_SCLP_BUS;
+}
+
+static TypeInfo s390_sclp_device_info = {
+ .name = TYPE_DEVICE_S390_SCLP,
+ .parent = TYPE_DEVICE,
+ .instance_size = sizeof(S390SCLPDevice),
+ .class_init = s390_sclp_device_class_init,
+ .class_size = sizeof(S390SCLPDeviceClass),
+ .abstract = true,
+};
+
static void s390_sclp_register_types(void)
{
type_register_static(&s390_sclp_bridge_info);
type_register_static(&s390_sclp_bus_info);
+ type_register_static(&s390_sclp_device_info);
}
type_init(s390_sclp_register_types)
diff --git a/hw/s390-sclp.h b/hw/s390-sclp.h
index f7bf140..24014eb 100644
--- a/hw/s390-sclp.h
+++ b/hw/s390-sclp.h
@@ -19,15 +19,35 @@
/* SCLP command codes */
#define SCLP_CMDW_READ_SCP_INFO 0x00020001
#define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
+#define SCLP_CMD_READ_EVENT_DATA 0x00770005
+#define SCLP_CMD_WRITE_EVENT_DATA 0x00760005
+#define SCLP_CMD_READ_EVENT_DATA 0x00770005
+#define SCLP_CMD_WRITE_EVENT_DATA 0x00760005
+#define SCLP_CMD_WRITE_EVENT_MASK 0x00780005
/* SCLP response codes */
#define SCLP_RC_NORMAL_READ_COMPLETION 0x0010
+#define SCLP_RC_NORMAL_COMPLETION 0x0020
#define SCLP_RC_INVALID_SCLP_COMMAND 0x01f0
+#define SCLP_RC_CONTAINED_EQUIPMENT_CHECK 0x0340
+#define SCLP_RC_INSUFFICIENT_SCCB_LENGTH 0x0300
+#define SCLP_RC_INVALID_FUNCTION 0x40f0
+#define SCLP_RC_NO_EVENT_BUFFERS_STORED 0x60f0
+#define SCLP_RC_INVALID_SELECTION_MASK 0x70f0
+#define SCLP_RC_INCONSISTENT_LENGTHS 0x72f0
+#define SCLP_RC_EVENT_BUFFER_SYNTAX_ERROR 0x73f0
+#define SCLP_RC_INVALID_MASK_LENGTH 0x74f0
+
/* Service Call Control Block (SCCB) and its elements */
#define SCCB_SIZE 4096
+#define SCLP_VARIABLE_LENGTH_RESPONSE 0x80
+#define SCLP_EVENT_BUFFER_ACCEPTED 0x80
+
+#define SCLP_FC_NORMAL_WRITE 0
+
/*
* Normally packed structures are not the right thing to do, since all code
* must take care of endianess. We cant use ldl_phys and friends for two
@@ -63,14 +83,37 @@ typedef struct SCCB {
#define TYPE_S390_SCLP_BUS "s390-sclp-bus"
+#define TYPE_DEVICE_S390_SCLP "s390-sclp-device"
+#define SCLP_S390_DEVIVE(obj) \
+ OBJECT_CHECK(S390SCLPDevice, (obj), TYPE_DEVICE_S390_SCLP)
+#define SCLP_S390_DEVICE_CLASS(klass) \
+ OBJECT_CLASS_CHECK(S390SCLPDeviceClass, (klass), \
+ TYPE_DEVICE_S390_SCLP)
+#define SCLP_S390_DEVICE_GET_CLASS(obj) \
+ OBJECT_GET_CLASS(S390SCLPDeviceClass, (obj), \
+ TYPE_DEVICE_S390_SCLP)
+
+typedef struct SCLPEventFacility SCLPEventFacility;
+
typedef struct S390SCLPDevice {
DeviceState qdev;
+ SCLPEventFacility *instance;
+ int (*sclp_command_handler)(SCCB *sccb, uint64_t code);
+ bool (*event_pending)(void);
} S390SCLPDevice;
typedef struct SCLPS390Bus {
BusState bus;
+ S390SCLPDevice *event_facility;
} SCLPS390Bus;
+typedef struct S390SCLPDeviceClass {
+ DeviceClass qdev;
+
+ int (*init)(S390SCLPDevice *sdev);
+
+} S390SCLPDeviceClass;
+
extern SCLPS390Bus *sclp_bus;
SCLPS390Bus *s390_sclp_bus_init(void);
diff --git a/hw/s390x/Makefile.objs b/hw/s390x/Makefile.objs
index b2d577b..5ebde3b 100644
--- a/hw/s390x/Makefile.objs
+++ b/hw/s390x/Makefile.objs
@@ -1,4 +1,4 @@
obj-y = s390-virtio-bus.o s390-virtio.o
-obj-y += s390-sclp.o
+obj-y += s390-sclp.o s390-event-facility.o
obj-y := $(addprefix ../,$(obj-y))
--
1.7.10.5
^ permalink raw reply related [flat|nested] 14+ messages in thread
* [Qemu-devel] [PATCH 4/6] s390: sclp signal quiesce support
2012-07-13 10:51 [Qemu-devel] [PATCH 0/6v2] s390: several sclp patches Christian Borntraeger
` (2 preceding siblings ...)
2012-07-13 10:52 ` [Qemu-devel] [PATCH 3/6] s390: sclp event support Christian Borntraeger
@ 2012-07-13 10:52 ` Christian Borntraeger
2012-07-13 10:52 ` [Qemu-devel] [PATCH 5/6] s390: sclp ascii console support Christian Borntraeger
2012-07-13 10:52 ` [Qemu-devel] [PATCH 6/6] s390: make sclp ascii console the default Christian Borntraeger
5 siblings, 0 replies; 14+ messages in thread
From: Christian Borntraeger @ 2012-07-13 10:52 UTC (permalink / raw)
To: Alexander Graf
Cc: Cornelia Huck, Christian Borntraeger, Jens Freimann,
Heinz Graalfs, qemu-devel
From: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
This implements the sclp signal quiesce event via the SCLP Event
Facility.
This allows to gracefully shutdown a guest by using system_powerdown.
It creates a service interrupt that will trigger a Read Event Data
command from the guest. This code will then add an event that is
interpreted by linux guests as ctrl-alt-del.
Signed-off-by: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
---
hw/s390-event-facility.c | 6 +++
hw/s390-sclpquiesce.c | 113 ++++++++++++++++++++++++++++++++++++++++++++++
hw/s390x/Makefile.objs | 2 +-
3 files changed, 120 insertions(+), 1 deletion(-)
create mode 100644 hw/s390-sclpquiesce.c
diff --git a/hw/s390-event-facility.c b/hw/s390-event-facility.c
index 42ac102..e3c9c56 100644
--- a/hw/s390-event-facility.c
+++ b/hw/s390-event-facility.c
@@ -335,6 +335,7 @@ static int command_handler(SCCB *sccb, uint64_t code)
static int init_event_facility(S390SCLPDevice *sdev)
{
SCLPEventFacility *event_facility;
+ DeviceState *quiesce;
event_facility = g_malloc0(sizeof(SCLPEventFacility));
sdev->instance = event_facility;
@@ -348,6 +349,11 @@ static int init_event_facility(S390SCLPDevice *sdev)
event_facility->sbus.event_facility = event_facility;
event_facility->qdev = (DeviceState *) sdev;
+ quiesce = qdev_create(&event_facility->sbus.qbus, "sclpquiesce");
+ if (!quiesce) {
+ return -1;
+ }
+ qdev_init_nofail(quiesce);
return 0;
}
diff --git a/hw/s390-sclpquiesce.c b/hw/s390-sclpquiesce.c
new file mode 100644
index 0000000..405664a
--- /dev/null
+++ b/hw/s390-sclpquiesce.c
@@ -0,0 +1,113 @@
+/*
+ * SCLP event type
+ * Signal Quiesce - trigger system powerdown request
+ *
+ * Copyright IBM, Corp. 2007, 2012
+ *
+ * Authors:
+ * Heinz Graalfs <graalfs@de.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2. See
+ * the COPYING file in the top-level directory.
+ *
+ */
+#include "qdev.h"
+#include "sysemu.h"
+
+#include "s390-sclp.h"
+#include "s390-event-facility.h"
+
+typedef struct SignalQuiesce {
+ EventBufferHeader ebh;
+ uint16_t timeout;
+ uint8_t unit;
+} __attribute__((packed)) SignalQuiesce;
+
+static int event_type(void)
+{
+ return SCLP_EVENT_SIGNAL_QUIESCE;
+}
+
+static unsigned int send_mask(void)
+{
+ return SCLP_EVENT_MASK_SIGNAL_QUIESCE;
+}
+
+static unsigned int receive_mask(void)
+{
+ return 0;
+}
+
+static int read_event_data(SCLPEvent *event, EventBufferHeader *evt_buf_hdr,
+ int *slen)
+{
+ SignalQuiesce *sq = (SignalQuiesce *) evt_buf_hdr;
+
+ if (*slen < sizeof(SignalQuiesce)) {
+ return 0;
+ }
+
+ if (!event->event_pending) {
+ return 0;
+ }
+ event->event_pending = false;
+
+ sq->ebh.length = cpu_to_be16(sizeof(SignalQuiesce));
+ sq->ebh.type = SCLP_EVENT_SIGNAL_QUIESCE;
+ sq->ebh.flags |= SCLP_EVENT_BUFFER_ACCEPTED;
+ /*
+ * system_powerdown does not have a timeout. Fortunately the
+ * timeout value is currently ignored by Linux, anyway
+ */
+ sq->timeout = cpu_to_be16(0);
+ sq->unit = cpu_to_be16(0);
+ *slen -= sizeof(SignalQuiesce);
+
+ return 1;
+}
+
+static void trigger_signal_quiesce(void *opaque, int n, int level)
+{
+ SCLPEvent *event = opaque;
+
+ event->event_pending = true;
+ /* trigger SCLP read operation */
+ sclp_service_interrupt(0);
+}
+
+static int quiesce_init(SCLPEvent *event)
+{
+ event->event_type = SCLP_EVENT_SIGNAL_QUIESCE;
+ qemu_system_powerdown = *qemu_allocate_irqs(trigger_signal_quiesce,
+ event, 1);
+ qemu_mutex_init(&event->lock);
+
+ return 0;
+}
+
+static void quiesce_class_init(ObjectClass *klass, void *data)
+{
+ SCLPEventClass *k = SCLP_EVENT_CLASS(klass);
+
+ k->init = quiesce_init;
+
+ k->get_send_mask = send_mask;
+ k->get_receive_mask = receive_mask;
+ k->event_type = event_type;
+ k->read_event_data = read_event_data;
+ k->write_event_data = NULL;
+}
+
+static TypeInfo sclp_quiesce_info = {
+ .name = "sclpquiesce",
+ .parent = TYPE_SCLP_EVENT,
+ .instance_size = sizeof(SCLPEvent),
+ .class_init = quiesce_class_init,
+ .class_size = sizeof(SCLPEventClass),
+};
+
+static void register_types(void)
+{
+ type_register_static(&sclp_quiesce_info);
+}
+type_init(register_types)
diff --git a/hw/s390x/Makefile.objs b/hw/s390x/Makefile.objs
index 5ebde3b..a3ab189 100644
--- a/hw/s390x/Makefile.objs
+++ b/hw/s390x/Makefile.objs
@@ -1,4 +1,4 @@
obj-y = s390-virtio-bus.o s390-virtio.o
-obj-y += s390-sclp.o s390-event-facility.o
+obj-y += s390-sclp.o s390-event-facility.o s390-sclpquiesce.o
obj-y := $(addprefix ../,$(obj-y))
--
1.7.10.5
^ permalink raw reply related [flat|nested] 14+ messages in thread
* [Qemu-devel] [PATCH 5/6] s390: sclp ascii console support
2012-07-13 10:51 [Qemu-devel] [PATCH 0/6v2] s390: several sclp patches Christian Borntraeger
` (3 preceding siblings ...)
2012-07-13 10:52 ` [Qemu-devel] [PATCH 4/6] s390: sclp signal quiesce support Christian Borntraeger
@ 2012-07-13 10:52 ` Christian Borntraeger
2012-07-13 10:52 ` [Qemu-devel] [PATCH 6/6] s390: make sclp ascii console the default Christian Borntraeger
5 siblings, 0 replies; 14+ messages in thread
From: Christian Borntraeger @ 2012-07-13 10:52 UTC (permalink / raw)
To: Alexander Graf
Cc: Cornelia Huck, Christian Borntraeger, Jens Freimann,
Heinz Graalfs, qemu-devel
From: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
This code adds console support by implementing SCLP's ASCII Console
Data event.
This is the same console as LPARs ASCII console or z/VMs sysascii.
When data is received from the character layer it creates a service
interrupt to trigger a Read Event Data command from the guest that will
pick up the received character byte-stream.
When characters are echo'ed by the linux guest a Write Event Data occurs
which is forwarded by the Event Facility to the console that supports
a corresponding mask value.
Console resizing is not supported.
The character layer byte-stream is buffered using a fixed size iov
buffer.
Signed-off-by: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
---
hw/s390-sclpconsole.c | 313 ++++++++++++++++++++++++++++++++++++++++++++++++
hw/s390x/Makefile.objs | 2 +-
2 files changed, 314 insertions(+), 1 deletion(-)
create mode 100644 hw/s390-sclpconsole.c
diff --git a/hw/s390-sclpconsole.c b/hw/s390-sclpconsole.c
new file mode 100644
index 0000000..db692d2
--- /dev/null
+++ b/hw/s390-sclpconsole.c
@@ -0,0 +1,313 @@
+/*
+ * SCLP event type
+ * Ascii Console Data (VT220 Console)
+ *
+ * Copyright IBM, Corp. 2007, 2012
+ *
+ * Authors:
+ * Heinz Graalfs <graalfs@de.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2. See
+ * the COPYING file in the top-level directory.
+ *
+ */
+
+#include "qdev.h"
+#include "qemu-thread.h"
+
+#include "s390-sclp.h"
+#include "s390-event-facility.h"
+
+typedef struct ASCIIConsoleData {
+ EventBufferHeader ebh;
+ char data[0];
+} __attribute__((packed)) ASCIIConsoleData;
+
+qemu_irq sclp_read_vt220;
+
+/* max size for ASCII data in 4K SCCB page */
+#define SIZE_BUFFER_VT220 4080
+
+typedef struct SCLPConsole {
+ SCLPEvent event;
+ CharDriverState *chr;
+ /* io vector */
+ uint8_t *iov; /* iov buffer pointer */
+ uint8_t *iov_sclp; /* pointer to SCLP read offset */
+ uint8_t *iov_bs; /* pointer byte stream read offset */
+ uint32_t iov_data_len; /* length of byte stream in buffer */
+ uint32_t iov_sclp_rest; /* length of byte stream not read via SCLP */
+} SCLPConsole;
+
+/* character layer call-back functions */
+
+/* Return number of bytes that fit into iov buffer */
+static int chr_can_read(void *opaque)
+{
+ int can_read;
+ SCLPConsole *scon = opaque;
+
+ qemu_mutex_lock(&scon->event.lock);
+ can_read = SIZE_BUFFER_VT220 - scon->iov_data_len;
+ qemu_mutex_unlock(&scon->event.lock);
+
+ return can_read;
+}
+
+/* Receive n bytes from character layer, save in iov buffer,
+ * and set event pending */
+static void receive_from_chr_layer(void *opaque, const uint8_t *buf, int size)
+{
+ SCLPConsole *scon = opaque;
+
+ qemu_mutex_lock(&scon->event.lock);
+
+ /* if new data do not fit into current buffer */
+ if (scon->iov_data_len + size > SIZE_BUFFER_VT220) {
+ /* character layer sent more than allowed */
+ qemu_mutex_unlock(&scon->event.lock);
+ return;
+ }
+ /* put byte-stream from character layer into buffer */
+ memcpy(scon->iov_bs, buf, size);
+ scon->iov_data_len += size;
+ scon->iov_sclp_rest += size;
+ scon->iov_bs += size;
+ scon->event.event_pending = true;
+
+ qemu_mutex_unlock(&scon->event.lock);
+}
+
+/* Send data from a char device over to the guest */
+static void chr_read(void *opaque, const uint8_t *buf, int size)
+{
+ receive_from_chr_layer(opaque, buf, size);
+ /* trigger SCLP read operation */
+ qemu_irq_raise(sclp_read_vt220);
+}
+
+static void chr_event(void *opaque, int event)
+{
+ SCLPConsole *scon = opaque;
+
+ switch (event) {
+ case CHR_EVENT_OPENED:
+ if (!scon->iov) {
+ scon->iov = g_malloc0(SIZE_BUFFER_VT220);
+ scon->iov_sclp = scon->iov;
+ scon->iov_bs = scon->iov;
+ scon->iov_data_len = 0;
+ scon->iov_sclp_rest = 0;
+ }
+ break;
+ case CHR_EVENT_CLOSED:
+ if (scon->iov) {
+ g_free(scon->iov);
+ scon->iov = NULL;
+ }
+ break;
+ }
+}
+
+/* functions to be called by event facility */
+
+static int event_type(void)
+{
+ return SCLP_EVENT_ASCII_CONSOLE_DATA;
+}
+
+static unsigned int send_mask(void)
+{
+ return SCLP_EVENT_MASK_MSG_ASCII;
+}
+
+static unsigned int receive_mask(void)
+{
+ return SCLP_EVENT_MASK_MSG_ASCII;
+}
+
+/* triggered by SCLP's read_event_data -
+ * copy console data byte-stream into provided (SCLP) buffer
+ * returns -1 if no event data pending
+ * */
+static void get_console_data(SCLPEvent *event, uint8_t *buf, size_t *size,
+ int avail)
+{
+ SCLPConsole *cons = DO_UPCAST(SCLPConsole, event, event);
+
+ /* first byte is hex 0 saying an ascii string follows */
+ *buf++ = '\0';
+ avail--;
+ /* if all data fit into provided SCLP buffer */
+ if (avail >= cons->iov_sclp_rest) {
+ /* copy character byte-stream to SCLP buffer */
+ memcpy(buf, cons->iov_sclp, cons->iov_sclp_rest);
+ *size = cons->iov_sclp_rest + 1;
+ cons->iov_sclp = cons->iov;
+ cons->iov_bs = cons->iov;
+ cons->iov_data_len = 0;
+ cons->iov_sclp_rest = 0;
+ event->event_pending = false;
+ /* data provided and no more data pending */
+ } else {
+ /* if provided buffer is too small, just copy part */
+ memcpy(buf, cons->iov_sclp, avail);
+ *size = avail + 1;
+ cons->iov_sclp_rest -= avail;
+ cons->iov_sclp += avail;
+ /* more data pending */
+ }
+}
+
+static int read_event_data(SCLPEvent *event, EventBufferHeader *evt_buf_hdr,
+ int *slen)
+{
+ int avail;
+ size_t src_len;
+ uint8_t *to;
+ ASCIIConsoleData *acd = (ASCIIConsoleData *) evt_buf_hdr;
+
+ qemu_mutex_lock(&event->lock);
+
+ if (!event->event_pending) {
+ /* no data pending */
+ qemu_mutex_unlock(&event->lock);
+ return 0;
+ }
+
+ to = (uint8_t *)&acd->data;
+ avail = *slen - sizeof(ASCIIConsoleData);
+ get_console_data(event, to, &src_len, avail);
+
+ acd->ebh.length = cpu_to_be16(sizeof(ASCIIConsoleData) + src_len);
+ acd->ebh.type = SCLP_EVENT_ASCII_CONSOLE_DATA;
+ acd->ebh.flags |= SCLP_EVENT_BUFFER_ACCEPTED;
+ *slen = avail - src_len;
+
+ qemu_mutex_unlock(&event->lock);
+
+ return 1;
+}
+
+/* triggered by SCLP's write_event_data
+ * - write console data into character layer
+ * returns < 0 if an error occured
+ */
+static ssize_t write_console_data(SCLPEvent *event, const uint8_t *buf,
+ size_t len)
+{
+ ssize_t ret = 0;
+ const uint8_t *iov_offset;
+ SCLPConsole *scon = DO_UPCAST(SCLPConsole, event, event);
+
+ if (!scon->chr) {
+ /* If there's no backend, we can just say we consumed all data. */
+ return len;
+ }
+
+ iov_offset = buf;
+ while (len > 0) {
+ ret = qemu_chr_fe_write(scon->chr, buf, len);
+ if (ret == 0) {
+ /* a pty doesn't seem to be connected - no error */
+ len = 0;
+ } else if (ret == -EAGAIN || (ret > 0 && ret < len)) {
+ len -= ret;
+ iov_offset += ret;
+ } else {
+ len = 0;
+ }
+ }
+
+ return ret;
+}
+
+static int write_event_data(SCLPEvent *event, EventBufferHeader *evt_buf_hdr)
+{
+ int rc;
+ int length;
+ ssize_t written;
+ ASCIIConsoleData *acd = (ASCIIConsoleData *) evt_buf_hdr;
+
+ length = evt_buf_hdr->length - sizeof(EventBufferHeader);
+ written = write_console_data(event, (uint8_t *)acd->data, length);
+
+ rc = SCLP_RC_NORMAL_COMPLETION;
+ /* set event buffer accepted flag */
+ evt_buf_hdr->flags |= SCLP_EVENT_BUFFER_ACCEPTED;
+
+ /* written will be zero if a pty is not connected - don't treat as error */
+ if (written < 0) {
+ /* event buffer not accepted due to error in character layer */
+ evt_buf_hdr->flags &= ~(SCLP_EVENT_BUFFER_ACCEPTED);
+ rc = SCLP_RC_CONTAINED_EQUIPMENT_CHECK;
+ }
+
+ return rc;
+}
+
+static void trigger_ascii_console_data(void *env, int n, int level)
+{
+ sclp_service_interrupt(0);
+}
+
+/* qemu object creation and initialization functions */
+
+/* tell character layer our call-back functions */
+static int console_init(SCLPEvent *event)
+{
+ SCLPConsole *scon = DO_UPCAST(SCLPConsole, event, event);
+
+ event->event_type = SCLP_EVENT_ASCII_CONSOLE_DATA;
+ if (scon->chr) {
+ qemu_chr_add_handlers(scon->chr, chr_can_read,
+ chr_read, chr_event, scon);
+ }
+ sclp_read_vt220 = *qemu_allocate_irqs(trigger_ascii_console_data,
+ NULL, 1);
+
+ qemu_mutex_init(&event->lock);
+
+ return 0;
+}
+
+static int console_exit(SCLPEvent *event)
+{
+ qemu_mutex_destroy(&event->lock);
+
+ return 0;
+}
+
+static Property console_properties[] = {
+ DEFINE_PROP_CHR("chardev", SCLPConsole, chr),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void console_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ SCLPEventClass *ec = SCLP_EVENT_CLASS(klass);
+
+ dc->props = console_properties;
+ ec->init = console_init;
+ ec->exit = console_exit;
+ ec->get_send_mask = send_mask;
+ ec->get_receive_mask = receive_mask;
+ ec->event_type = event_type;
+ ec->read_event_data = read_event_data;
+ ec->write_event_data = write_event_data;
+}
+
+static TypeInfo sclp_console_info = {
+ .name = "sclpconsole",
+ .parent = TYPE_SCLP_EVENT,
+ .instance_size = sizeof(SCLPConsole),
+ .class_init = console_class_init,
+ .class_size = sizeof(SCLPEventClass),
+};
+
+static void register_types(void)
+{
+ type_register_static(&sclp_console_info);
+}
+type_init(register_types)
diff --git a/hw/s390x/Makefile.objs b/hw/s390x/Makefile.objs
index a3ab189..e1abb00 100644
--- a/hw/s390x/Makefile.objs
+++ b/hw/s390x/Makefile.objs
@@ -1,4 +1,4 @@
obj-y = s390-virtio-bus.o s390-virtio.o
-obj-y += s390-sclp.o s390-event-facility.o s390-sclpquiesce.o
+obj-y += s390-sclp.o s390-event-facility.o s390-sclpconsole.o s390-sclpquiesce.o
obj-y := $(addprefix ../,$(obj-y))
--
1.7.10.5
^ permalink raw reply related [flat|nested] 14+ messages in thread
* [Qemu-devel] [PATCH 6/6] s390: make sclp ascii console the default
2012-07-13 10:51 [Qemu-devel] [PATCH 0/6v2] s390: several sclp patches Christian Borntraeger
` (4 preceding siblings ...)
2012-07-13 10:52 ` [Qemu-devel] [PATCH 5/6] s390: sclp ascii console support Christian Borntraeger
@ 2012-07-13 10:52 ` Christian Borntraeger
5 siblings, 0 replies; 14+ messages in thread
From: Christian Borntraeger @ 2012-07-13 10:52 UTC (permalink / raw)
To: Alexander Graf
Cc: Cornelia Huck, Christian Borntraeger, Jens Freimann,
Heinz Graalfs, qemu-devel
This patch makes the sclp ascii default for S390.
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
---
hw/s390-virtio.c | 1 -
vl.c | 40 ++++++++++++++++++++++++++++++++++++++++
2 files changed, 40 insertions(+), 1 deletion(-)
diff --git a/hw/s390-virtio.c b/hw/s390-virtio.c
index 577fcee..ae53da2 100644
--- a/hw/s390-virtio.c
+++ b/hw/s390-virtio.c
@@ -342,7 +342,6 @@ static QEMUMachine s390_machine = {
.no_serial = 1,
.no_parallel = 1,
.no_sdcard = 1,
- .use_virtcon = 1,
.max_cpus = 255,
.is_default = 1,
};
diff --git a/vl.c b/vl.c
index 1329c30..42741e9 100644
--- a/vl.c
+++ b/vl.c
@@ -168,6 +168,7 @@ int main(int argc, char **argv)
#define DEFAULT_RAM_SIZE 128
#define MAX_VIRTIO_CONSOLES 1
+#define MAX_SCLP_CONSOLES 1
static const char *data_dir;
const char *bios_name = NULL;
@@ -195,6 +196,7 @@ int no_quit = 0;
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
+CharDriverState *sclpcon_hds[MAX_SCLP_CONSOLES];
int win2k_install_hack = 0;
int usb_enabled = 0;
int singlestep = 0;
@@ -268,6 +270,7 @@ static int default_floppy = 1;
static int default_cdrom = 1;
static int default_sdcard = 1;
static int default_vga = 1;
+static int default_sclpcon = 1;
static struct {
const char *driver;
@@ -289,6 +292,7 @@ static struct {
{ .driver = "isa-cirrus-vga", .flag = &default_vga },
{ .driver = "vmware-svga", .flag = &default_vga },
{ .driver = "qxl-vga", .flag = &default_vga },
+ { .driver = "s390-sclp", .flag = &default_sclpcon },
};
static void res_free(void)
@@ -1936,6 +1940,7 @@ struct device_config {
DEV_VIRTCON, /* -virtioconsole */
DEV_DEBUGCON, /* -debugcon */
DEV_GDB, /* -gdb, -s */
+ DEV_SCLPCON, /* sclp console */
} type;
const char *cmdline;
Location loc;
@@ -2015,6 +2020,36 @@ static int parallel_parse(const char *devname)
return 0;
}
+static int sclpcon_parse(const char *devname)
+{
+ QemuOptsList *device = qemu_find_opts("device");
+ static int index = 0;
+ char label[32];
+ QemuOpts *dev_opts;
+
+ if (strcmp(devname, "none") == 0)
+ return 0;
+ if (index == MAX_SCLP_CONSOLES) {
+ fprintf(stderr, "qemu: too many sclp consoles\n");
+ exit(1);
+ }
+
+ dev_opts = qemu_opts_create(device, NULL, 0, NULL);
+ qemu_opt_set(dev_opts, "driver", "sclpconsole");
+
+ snprintf(label, sizeof(label), "sclpcon%d", index);
+ sclpcon_hds[index] = qemu_chr_new(label, devname, NULL);
+ if (!sclpcon_hds[index]) {
+ fprintf(stderr, "qemu: could not open sclp console '%s': %s\n",
+ devname, strerror(errno));
+ return -1;
+ }
+ qemu_opt_set(dev_opts, "chardev", label);
+
+ index++;
+ return 0;
+}
+
static int virtcon_parse(const char *devname)
{
QemuOptsList *device = qemu_find_opts("device");
@@ -3123,6 +3158,7 @@ int main(int argc, char **argv, char **envp)
default_cdrom = 0;
default_sdcard = 0;
default_vga = 0;
+ default_sclpcon = 0;
break;
case QEMU_OPTION_xen_domid:
if (!(xen_available())) {
@@ -3304,6 +3340,8 @@ int main(int argc, char **argv, char **envp)
add_device_config(DEV_PARALLEL, "null");
if (default_serial && default_monitor) {
add_device_config(DEV_SERIAL, "mon:stdio");
+ } else if (default_sclpcon && default_monitor) {
+ add_device_config(DEV_SCLPCON, "mon:stdio");
} else if (default_virtcon && default_monitor) {
add_device_config(DEV_VIRTCON, "mon:stdio");
} else {
@@ -3491,6 +3529,8 @@ int main(int argc, char **argv, char **envp)
exit(1);
if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
exit(1);
+ if (foreach_device_config(DEV_SCLPCON, sclpcon_parse) < 0)
+ exit(1);
if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
exit(1);
if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
--
1.7.10.5
^ permalink raw reply related [flat|nested] 14+ messages in thread
* Re: [Qemu-devel] [PATCH 2/6] s390: sclp base support
2012-07-13 10:52 ` [Qemu-devel] [PATCH 2/6] s390: sclp base support Christian Borntraeger
@ 2012-07-13 15:08 ` Blue Swirl
2012-07-13 16:44 ` Christian Borntraeger
2012-07-20 14:06 ` Andreas Färber
1 sibling, 1 reply; 14+ messages in thread
From: Blue Swirl @ 2012-07-13 15:08 UTC (permalink / raw)
To: Christian Borntraeger
Cc: Cornelia Huck, Jens Freimann, Heinz Graalfs, Alexander Graf, qemu-devel
On Fri, Jul 13, 2012 at 10:52 AM, Christian Borntraeger
<borntraeger@de.ibm.com> wrote:
> From: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
>
> This adds a more generic infrastructure for handling Service-Call
> requests on s390. Currently we only support a small subset of Read
> SCP Info directly in target-s390x. This patch provides the base
> infrastructure for supporting more commands and moves Read SCP
> Info.
> In the future we could add additional commands for hotplug, call
> home and event handling.
>
> Signed-off-by: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
> Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
> ---
> hw/s390-sclp.c | 148 ++++++++++++++++++++++++++++++++++++++++++++++
> hw/s390-sclp.h | 80 +++++++++++++++++++++++++
> hw/s390-virtio.c | 3 +
> hw/s390x/Makefile.objs | 1 +
> target-s390x/cpu.c | 17 ++++++
> target-s390x/cpu.h | 18 ++----
> target-s390x/kvm.c | 5 +-
> target-s390x/op_helper.c | 45 ++------------
> 8 files changed, 261 insertions(+), 56 deletions(-)
> create mode 100644 hw/s390-sclp.c
> create mode 100644 hw/s390-sclp.h
>
> diff --git a/hw/s390-sclp.c b/hw/s390-sclp.c
> new file mode 100644
> index 0000000..74a3e66
> --- /dev/null
> +++ b/hw/s390-sclp.c
> @@ -0,0 +1,148 @@
> +/*
> + * SCLP Support
> + *
> + * Copyright IBM, Corp. 2007, 2012
2007, really?
> + *
> + * Authors:
> + * Christian Borntraeger <borntraeger@de.ibm.com>
> + * Heinz Graalfs <graalfs@linux.vnet.ibm.com>
> + *
> + * This work is licensed under the terms of the GNU GPL, version 2. See
Why GPLv2only, can't this be licensed under later versions?
> + * the COPYING file in the top-level directory.
> + *
> + */
> +
> +#include "cpu.h"
> +#include "kvm.h"
> +#include "sysbus.h"
> +
> +#include "s390-sclp.h"
> +
> +/* Provide information about the configuration, CPUs and storage */
> +static int read_SCP_info(SCCB *sccb)
> +{
> + ReadInfo *read_info = (ReadInfo *) sccb;
> + int shift = 0;
> +
> + while ((ram_size >> (20 + shift)) > 65535) {
> + shift++;
> + }
> + read_info->rnmax = cpu_to_be16(ram_size >> (20 + shift));
> + read_info->rnsize = 1 << shift;
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
> +
> + return 0;
> +}
> +
> +static int sclp_execute(SCCB *sccb, uint64_t code)
> +{
> + int r = 0;
> +
> + switch (code) {
> + case SCLP_CMDW_READ_SCP_INFO:
> + case SCLP_CMDW_READ_SCP_INFO_FORCED:
> + r = read_SCP_info(sccb);
> + break;
> + default:
> +#ifdef DEBUG_HELPER
> + printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
> +#endif
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
> + break;
> + }
> + return r;
> +}
> +
> +int do_sclp_service_call(uint32_t sccb, uint64_t code)
sccb could be target_phys_addr_t.
> +{
> + int r = 0;
> + SCCB work_sccb;
> +
> + target_phys_addr_t sccb_len = sizeof(SCCB);
> +
> + /*
> + * we want to work on a private copy of the sccb, to prevent guests
> + * from playing dirty tricks by modifying the memory content after
> + * the host has checked the values
> + */
> + cpu_physical_memory_read(sccb, &work_sccb, sccb_len);
> +
> + /* Valid sccb sizes */
> + if (be16_to_cpu(work_sccb.h.length) < 8 ||
> + be16_to_cpu(work_sccb.h.length) > 4096) {
> + r = -PGM_SPECIFICATION;
> + goto out;
> + }
> +
> + r = sclp_execute((SCCB *)&work_sccb, code);
> +
> + cpu_physical_memory_write(sccb, &work_sccb,
> + be16_to_cpu(work_sccb.h.length));
Perhaps the DMA helpers should be used instead.
> + if (!r) {
> + sclp_service_interrupt(sccb);
> + }
> +
> +out:
> + return r;
> +}
> +
> +void sclp_service_interrupt(uint32_t sccb)
> +{
> + if (!sccb) {
> + return;
> + }
> + s390_sclp_extint(sccb & ~3);
> +}
> +
> +/* qemu object creation and initialization functions */
> +
> +#define S390_SCLP_BUS(obj) OBJECT_CHECK(SCLPS390Bus, (obj), TYPE_S390_SCLP_BUS)
> +static const TypeInfo s390_sclp_bus_info = {
> + .name = TYPE_S390_SCLP_BUS,
> + .parent = TYPE_BUS,
> + .instance_size = sizeof(SCLPS390Bus),
> + };
> +
> +SCLPS390Bus *s390_sclp_bus_init(void)
> +{
> + SCLPS390Bus *bus;
> + BusState *bus_state;
> + DeviceState *dev;
> +
> + dev = qdev_create(NULL, "s390-sclp-bridge");
> + qdev_init_nofail(dev);
> +
> + bus_state = qbus_create(TYPE_S390_SCLP_BUS, dev, "s390-sclp-bus");
> + bus_state->allow_hotplug = 0;
> +
> + bus = DO_UPCAST(SCLPS390Bus, bus, bus_state);
> + return bus;
> +}
> +
> +static int s390_sclp_bridge_init(SysBusDevice *dev)
> +{
> + return 0;
> +}
> +
> +static void s390_sclp_bridge_class_init(ObjectClass *klass, void *data)
> +{
> + DeviceClass *dc = DEVICE_CLASS(klass);
> + SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
> +
> + k->init = s390_sclp_bridge_init;
> + dc->no_user = 1;
> +}
> +
> +static TypeInfo s390_sclp_bridge_info = {
> + .name = "s390-sclp-bridge",
> + .parent = TYPE_SYS_BUS_DEVICE,
> + .instance_size = sizeof(SysBusDevice),
> + .class_init = s390_sclp_bridge_class_init,
> +};
> +
> +static void s390_sclp_register_types(void)
> +{
> + type_register_static(&s390_sclp_bridge_info);
> + type_register_static(&s390_sclp_bus_info);
> +}
> +type_init(s390_sclp_register_types)
> diff --git a/hw/s390-sclp.h b/hw/s390-sclp.h
> new file mode 100644
> index 0000000..f7bf140
> --- /dev/null
> +++ b/hw/s390-sclp.h
> @@ -0,0 +1,80 @@
> +/*
> + * SCLP Support
> + *
> + * Copyright IBM, Corp. 2007, 2012
> + *
> + * Authors:
> + * Christian Borntraeger <borntraeger@de.ibm.com>
> + *
> + * This work is licensed under the terms of the GNU GPL, version 2. See
> + * the COPYING file in the top-level directory.
> + *
> + */
> +
> +#ifndef _QEMU_S390_SCLP_H
> +#define _QEMU_S390_SCLP_H
HW_S390_SCLP_H
> +
> +#include "qdev.h"
> +
> +/* SCLP command codes */
> +#define SCLP_CMDW_READ_SCP_INFO 0x00020001
> +#define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
> +
> +/* SCLP response codes */
> +#define SCLP_RC_NORMAL_READ_COMPLETION 0x0010
> +#define SCLP_RC_INVALID_SCLP_COMMAND 0x01f0
> +
> +/* Service Call Control Block (SCCB) and its elements */
> +
> +#define SCCB_SIZE 4096
> +
> +/*
> + * Normally packed structures are not the right thing to do, since all code
> + * must take care of endianess. We cant use ldl_phys and friends for two
> + * reasons, though:
> + * - some of the embedded structures below the SCCB can appear multiple times
> + * at different locations, so there is no fixed offset
> + * - we work on a private copy of the SCCB, since there are several length
> + * fields, that would cause a security nightmare if we allow the guest to
> + * alter the structure while we parse it. We cannot use ldl_p and friends
> + * either without doing pointer arithmetics
> + * So we have to double check that all users of sclp data structures use the
> + * right endianess wrappers.
> + */
> +typedef struct SCCBHeader {
> + uint16_t length;
> + uint8_t function_code;
> + uint8_t control_mask[3];
> + uint16_t response_code;
> +} __attribute__((packed)) SCCBHeader;
QEMU_PACKED
> +
> +#define SCCB_DATA_LEN (SCCB_SIZE - sizeof(SCCBHeader))
> +
> +typedef struct ReadInfo {
> + SCCBHeader h;
> + uint16_t rnmax;
> + uint8_t rnsize;
> +} __attribute__((packed)) ReadInfo;
> +
> +typedef struct SCCB {
> + SCCBHeader h;
> + char data[SCCB_DATA_LEN];
> + } __attribute__((packed)) SCCB;
> +
> +#define TYPE_S390_SCLP_BUS "s390-sclp-bus"
> +
> +typedef struct S390SCLPDevice {
> + DeviceState qdev;
> +} S390SCLPDevice;
> +
> +typedef struct SCLPS390Bus {
> + BusState bus;
> +} SCLPS390Bus;
> +
> +extern SCLPS390Bus *sclp_bus;
Global state is suspicious, usually it can be avoided with parameter passing.
> +
> +SCLPS390Bus *s390_sclp_bus_init(void);
> +
> +void sclp_service_interrupt(uint32_t sccb);
> +
> +#endif
> diff --git a/hw/s390-virtio.c b/hw/s390-virtio.c
> index 47eed35..577fcee 100644
> --- a/hw/s390-virtio.c
> +++ b/hw/s390-virtio.c
> @@ -32,6 +32,7 @@
> #include "exec-memory.h"
>
> #include "hw/s390-virtio-bus.h"
> +#include "hw/s390-sclp.h"
>
> //#define DEBUG_S390
>
> @@ -61,6 +62,7 @@
> #define MAX_BLK_DEVS 10
>
> static VirtIOS390Bus *s390_bus;
> +SCLPS390Bus *sclp_bus;
> static S390CPU **ipi_states;
>
> S390CPU *s390_cpu_addr2state(uint16_t cpu_addr)
> @@ -183,6 +185,7 @@ static void s390_init(ram_addr_t my_ram_size,
>
> /* get a BUS */
> s390_bus = s390_virtio_bus_init(&my_ram_size);
> + sclp_bus = s390_sclp_bus_init();
>
> /* allocate RAM */
> memory_region_init_ram(ram, "s390.ram", my_ram_size);
> diff --git a/hw/s390x/Makefile.objs b/hw/s390x/Makefile.objs
> index dcdcac8..b2d577b 100644
> --- a/hw/s390x/Makefile.objs
> +++ b/hw/s390x/Makefile.objs
> @@ -1,3 +1,4 @@
> obj-y = s390-virtio-bus.o s390-virtio.o
> +obj-y += s390-sclp.o
>
> obj-y := $(addprefix ../,$(obj-y))
> diff --git a/target-s390x/cpu.c b/target-s390x/cpu.c
> index 619b202..8900872 100644
> --- a/target-s390x/cpu.c
> +++ b/target-s390x/cpu.c
> @@ -21,9 +21,26 @@
> */
>
> #include "cpu.h"
> +#include "kvm.h"
> #include "qemu-common.h"
> #include "qemu-timer.h"
>
> +/* service interrupts are floating therefore we must not pass an cpustate */
> +void s390_sclp_extint(uint32_t parm)
> +{
> + S390CPU *dummy_cpu = s390_cpu_addr2state(0);
> + CPUS390XState *env = &dummy_cpu->env;
> +
> + if (kvm_enabled()) {
> +#ifdef CONFIG_KVM
> + kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE, parm, 0, 1);
> +#endif
> + } else {
> + env->psw.addr += 4;
> + cpu_inject_ext(env, EXT_SERVICE, parm, 0);
> + }
> +}
> +
>
> /* CPUClass::reset() */
> static void s390_cpu_reset(CPUState *s)
> diff --git a/target-s390x/cpu.h b/target-s390x/cpu.h
> index c30ac3a..abdd838 100644
> --- a/target-s390x/cpu.h
> +++ b/target-s390x/cpu.h
> @@ -294,6 +294,7 @@ void s390x_tod_timer(void *opaque);
> void s390x_cpu_timer(void *opaque);
>
> int s390_virtio_hypercall(CPUS390XState *env, uint64_t mem, uint64_t hypercall);
> +int do_sclp_service_call(uint32_t sccb, uint64_t code);
>
> #ifdef CONFIG_KVM
> void kvm_s390_interrupt(CPUS390XState *env, int type, uint32_t code);
> @@ -315,11 +316,15 @@ static inline void kvm_s390_interrupt_internal(CPUS390XState *env, int type,
> int vm)
> {
> }
> +
> #endif
> S390CPU *s390_cpu_addr2state(uint16_t cpu_addr);
> void s390_add_running_cpu(CPUS390XState *env);
> unsigned s390_del_running_cpu(CPUS390XState *env);
>
> +/* service interrupts are floating therefore we must not pass an cpustate */
> +void s390_sclp_extint(uint32_t parm);
> +
> /* from s390-virtio-bus */
> extern const target_phys_addr_t virtio_size;
>
> @@ -593,17 +598,6 @@ static inline const char *cc_name(int cc_op)
> return cc_names[cc_op];
> }
>
> -/* SCLP PV interface defines */
> -#define SCLP_CMDW_READ_SCP_INFO 0x00020001
> -#define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
> -
> -#define SCP_LENGTH 0x00
> -#define SCP_FUNCTION_CODE 0x02
> -#define SCP_CONTROL_MASK 0x03
> -#define SCP_RESPONSE_CODE 0x06
> -#define SCP_MEM_CODE 0x08
> -#define SCP_INCREMENT 0x0a
> -
> typedef struct LowCore
> {
> /* prefix area: defined by architecture */
> @@ -952,7 +946,7 @@ static inline void ebcdic_put(uint8_t *p, const char *ascii, int len)
> void load_psw(CPUS390XState *env, uint64_t mask, uint64_t addr);
> int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
> target_ulong *raddr, int *flags);
> -int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code);
> +int sclp_service_call(uint32_t sccb, uint64_t code);
> uint32_t calc_cc(CPUS390XState *env, uint32_t cc_op, uint64_t src, uint64_t dst,
> uint64_t vr);
>
> diff --git a/target-s390x/kvm.c b/target-s390x/kvm.c
> index 654f87d..68c4f3e 100644
> --- a/target-s390x/kvm.c
> +++ b/target-s390x/kvm.c
> @@ -60,9 +60,6 @@
> #define SIGP_STORE_STATUS_ADDR 0x0e
> #define SIGP_SET_ARCH 0x12
>
> -#define SCLP_CMDW_READ_SCP_INFO 0x00020001
> -#define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
> -
> const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
> KVM_CAP_LAST_INFO
> };
> @@ -237,7 +234,7 @@ static int kvm_sclp_service_call(CPUS390XState *env, struct kvm_run *run,
> sccb = env->regs[ipbh0 & 0xf];
> code = env->regs[(ipbh0 & 0xf0) >> 4];
>
> - r = sclp_service_call(env, sccb, code);
> + r = sclp_service_call(sccb, code);
> if (r < 0) {
> enter_pgmcheck(env, -r);
> }
> diff --git a/target-s390x/op_helper.c b/target-s390x/op_helper.c
> index 91dd8dc..e7bb980 100644
> --- a/target-s390x/op_helper.c
> +++ b/target-s390x/op_helper.c
> @@ -2362,20 +2362,12 @@ static void program_interrupt(CPUS390XState *env, uint32_t code, int ilc)
> }
> }
>
> -static void ext_interrupt(CPUS390XState *env, int type, uint32_t param,
> - uint64_t param64)
> -{
> - cpu_inject_ext(env, type, param, param64);
> -}
> -
> /*
> + * we handle here the part that belongs to the cpu, e.g. program checks
> * ret < 0 indicates program check, ret = 0,1,2,3 -> cc
> */
> -int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code)
> +int sclp_service_call(uint32_t sccb, uint64_t code)
> {
> - int r = 0;
> - int shift = 0;
> -
> #ifdef DEBUG_HELPER
> printf("sclp(0x%x, 0x%" PRIx64 ")\n", sccb, code);
> #endif
> @@ -2388,35 +2380,8 @@ int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code)
> return -PGM_SPECIFICATION;
> }
>
> - switch(code) {
> - case SCLP_CMDW_READ_SCP_INFO:
> - case SCLP_CMDW_READ_SCP_INFO_FORCED:
> - while ((ram_size >> (20 + shift)) > 65535) {
> - shift++;
> - }
> - stw_phys(sccb + SCP_MEM_CODE, ram_size >> (20 + shift));
> - stb_phys(sccb + SCP_INCREMENT, 1 << shift);
> - stw_phys(sccb + SCP_RESPONSE_CODE, 0x10);
> -
> - if (kvm_enabled()) {
> -#ifdef CONFIG_KVM
> - kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE,
> - sccb & ~3, 0, 1);
> -#endif
> - } else {
> - env->psw.addr += 4;
> - ext_interrupt(env, EXT_SERVICE, sccb & ~3, 0);
> - }
> - break;
> - default:
> -#ifdef DEBUG_HELPER
> - printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
> -#endif
> - r = 3;
> - break;
> - }
> -
> - return r;
> + /* the complex part is handled by external components */
> + return do_sclp_service_call(sccb, code);
> }
>
> /* SCLP service call */
> @@ -2424,7 +2389,7 @@ uint32_t HELPER(servc)(uint32_t r1, uint64_t r2)
> {
> int r;
>
> - r = sclp_service_call(env, r1, r2);
> + r = sclp_service_call(r1, r2);
> if (r < 0) {
> program_interrupt(env, -r, 4);
> return 0;
> --
> 1.7.10.5
>
>
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [Qemu-devel] [PATCH 3/6] s390: sclp event support
2012-07-13 10:52 ` [Qemu-devel] [PATCH 3/6] s390: sclp event support Christian Borntraeger
@ 2012-07-13 15:10 ` Blue Swirl
0 siblings, 0 replies; 14+ messages in thread
From: Blue Swirl @ 2012-07-13 15:10 UTC (permalink / raw)
To: Christian Borntraeger
Cc: Cornelia Huck, Jens Freimann, Heinz Graalfs, Alexander Graf, qemu-devel
On Fri, Jul 13, 2012 at 10:52 AM, Christian Borntraeger
<borntraeger@de.ibm.com> wrote:
> From: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
>
> Several SCLP features are considered to be events. Those events don't
> provide SCLP commands on their own, instead they are all based on
> Read Event Data, Write Event Data, Write Event Mask and the service
> interrupt. Follow-on patches will provide SCLP's Signal Quiesce (via
> system_powerdown) and the ASCII console.
> Further down the road the sclp line mode console and configuration
> change events (e.g. cpu hotplug) can be implemented.
>
> Signed-off-by: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
> Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
> ---
> hw/s390-event-facility.c | 412 ++++++++++++++++++++++++++++++++++++++++++++++
> hw/s390-event-facility.h | 107 ++++++++++++
> hw/s390-sclp.c | 49 +++++-
> hw/s390-sclp.h | 43 +++++
> hw/s390x/Makefile.objs | 2 +-
> 5 files changed, 606 insertions(+), 7 deletions(-)
> create mode 100644 hw/s390-event-facility.c
> create mode 100644 hw/s390-event-facility.h
>
> diff --git a/hw/s390-event-facility.c b/hw/s390-event-facility.c
> new file mode 100644
> index 0000000..42ac102
> --- /dev/null
> +++ b/hw/s390-event-facility.c
> @@ -0,0 +1,412 @@
> +/*
> + * SCLP
> + * Event Facility
> + * handles SCLP event types
> + * - Signal Quiesce - system power down
> + * - ASCII Console Data - VT220 read and write
> + *
> + * Copyright IBM, Corp. 2007, 2012
> + *
> + * Authors:
> + * Heinz Graalfs <graalfs@de.ibm.com>
> + *
> + * This work is licensed under the terms of the GNU GPL, version 2. See
> + * the COPYING file in the top-level directory.
> + *
> + */
> +
> +#include "monitor.h"
> +#include "sysemu.h"
> +
> +#include "s390-sclp.h"
> +#include "s390-event-facility.h"
> +
> +typedef struct EventTypes {
> + BusState qbus;
> + SCLPEventFacility *event_facility;
> +} EventTypes;
> +
> +struct SCLPEventFacility {
> + EventTypes sbus;
> + DeviceState *qdev;
> + /* guest' receive mask */
> + unsigned int receive_mask;
> +};
> +
> +/* return true if any child has event pending set */
> +static bool event_pending(void)
> +{
> + BusChild *kid;
> + SCLPEvent *event;
> +
> + SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
> +
> + QTAILQ_FOREACH(kid, &event_facility->sbus.qbus.children, sibling) {
> + DeviceState *qdev = kid->child;
> + event = DO_UPCAST(SCLPEvent, qdev, qdev);
> + lock(event);
> + if (event->event_pending) {
> + unlock(event);
> + return true;
> + }
> + unlock(event);
> + }
> + return false;
> +}
> +
> +static unsigned int get_host_send_mask(void)
> +{
> + unsigned int mask;
> + BusChild *kid;
> + SCLPEventClass *child;
> + SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
> +
> + mask = 0;
> +
> + QTAILQ_FOREACH(kid, &event_facility->sbus.qbus.children, sibling) {
> + DeviceState *qdev = kid->child;
> + child = SCLP_EVENT_GET_CLASS((SCLPEvent *) qdev);
> + mask |= child->get_send_mask();
> + }
> + return mask;
> +}
> +
> +static unsigned int get_host_receive_mask(void)
> +{
> + unsigned int mask;
> + BusChild *kid;
> + SCLPEventClass *child;
> + SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
> +
> + mask = 0;
> +
> + QTAILQ_FOREACH(kid, &event_facility->sbus.qbus.children, sibling) {
> + DeviceState *qdev = kid->child;
> + child = SCLP_EVENT_GET_CLASS((SCLPEvent *) qdev);
> + mask |= child->get_receive_mask();
> + }
> + return mask;
> +}
> +
> +static inline void set_guest_receive_mask(unsigned int mask)
> +{
> + SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
> +
> + event_facility->receive_mask = mask;
> +}
> +
> +static inline unsigned int get_guest_receive_mask(void)
> +{
> + SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
> +
> + return event_facility->receive_mask;
> +}
> +
> +static int check_sccb_events(SCCB *sccb)
bool? This returns only 0 or 1.
> +{
> + int slen;
> + unsigned elen = 0;
> + EventBufferHeader *event;
> + WriteEventData *wed = (WriteEventData *) sccb;
> +
> + event = (EventBufferHeader *) &wed->ebh;
> + for (slen = be16_to_cpu(sccb->h.length) - sizeof(sccb->h);
> + slen > 0; slen -= elen) {
> + elen = be16_to_cpu(event->length);
> + if (elen < sizeof(*event) || elen > slen) {
> + sccb->h.response_code =
> + cpu_to_be16(SCLP_RC_EVENT_BUFFER_SYNTAX_ERROR);
> + return 1;
> + }
> + event = (void *) event + elen;
> + }
> + if (slen) {
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_INCONSISTENT_LENGTHS);
> + return 1;
> + }
> + return 0;
> +}
> +
> +static void handle_sccb_write_events(SCCB *sccb)
> +{
> + int slen;
> + unsigned elen = 0;
> + EventBufferHeader *event_buf;
> + BusChild *kid;
> + SCLPEvent *event;
> + SCLPEventClass *ec;
> +
> + WriteEventData *wed = (WriteEventData *) sccb;
> +
> + SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
> +
> + event_buf = &wed->ebh;
> +
> + /* loop over all contained event buffers */
> + for (slen = be16_to_cpu(sccb->h.length) - sizeof(sccb->h);
> + 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 (sccb->h.response_code !=
> + cpu_to_be16(SCLP_RC_NORMAL_COMPLETION)) {
> + event_buf->flags &= ~(SCLP_EVENT_BUFFER_ACCEPTED);
> + } else {
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION);
> + QTAILQ_FOREACH(kid, &event_facility->sbus.qbus.children, sibling) {
> + DeviceState *qdev = kid->child;
> + event = (SCLPEvent *) qdev;
> + ec = SCLP_EVENT_GET_CLASS(event);
> +
> + if (ec->write_event_data &&
> + ec->event_type() == event_buf->type) {
> + sccb->h.response_code = cpu_to_be16(
> + ec->write_event_data(event, event_buf));
> + break;
> + }
> + }
> + }
> + event_buf = (void *) event_buf + elen;
> + }
> +}
> +
> +static int write_event_data(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 check the sum of all events */
> + if (check_sccb_events(sccb)) {
> + goto out;
> + }
> + /* then execute */
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
> + handle_sccb_write_events(sccb);
> +
> +out:
> + return 0;
> +}
> +
> +static void handle_sccb_read_events(SCCB *sccb, unsigned int mask)
> +{
> + int slen;
> + unsigned elen = 0;
> + BusChild *kid;
> + SCLPEvent *event;
> + SCLPEventClass *ec;
> + EventBufferHeader *event_buf;
> + ReadEventData *red = (ReadEventData *) sccb;
> +
> + SCLPEventFacility *event_facility = sclp_bus->event_facility->instance;
> +
> + event_buf = &red->ebh;
> + event_buf->length = 0;
> + slen = sizeof(sccb->data);
> + QTAILQ_FOREACH(kid, &event_facility->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)) {
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
> + }
> + }
> + elen = be16_to_cpu(event_buf->length);
> + event_buf = (void *) event_buf + elen;
> + }
> +
> + if (sccb->h.control_mask[2] & SCLP_VARIABLE_LENGTH_RESPONSE) {
> + sccb->h.control_mask[2] &= ~SCLP_VARIABLE_LENGTH_RESPONSE;
> + sccb->h.length = cpu_to_be16(SCCB_SIZE - slen);
> + }
> +}
> +
> +static int read_event_data(SCCB *sccb)
> +{
> + unsigned int sclp_active_selection_mask;
> + unsigned int sclp_cp_receive_mask;
> +
> + ReadEventData *red = (ReadEventData *) sccb;
> +
> + if (be16_to_cpu(sccb->h.length) != SCCB_SIZE) {
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
> + goto out;
> + }
> +
> + sclp_cp_receive_mask = get_guest_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:
> + if (!(sclp_cp_receive_mask & be32_to_cpu(red->mask))) {
> + sccb->h.response_code =
> + cpu_to_be16(SCLP_RC_INVALID_SELECTION_MASK);
> + goto out;
> + }
> + sclp_active_selection_mask = be32_to_cpu(red->mask);
> + break;
> + default:
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_FUNCTION);
> + goto out;
> + }
> +
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_NO_EVENT_BUFFERS_STORED);
> + handle_sccb_read_events(sccb, sclp_active_selection_mask);
> +
> +out:
> + return 0;
> +}
> +
> +static int write_event_mask(SCCB *sccb)
> +{
> + WriteEventMask *we_mask = (WriteEventMask *) sccb;
> +
> + /* Attention: We assume that Linux uses 4-byte masks, what it actually
> + does. Architecture allows for masks of variable size, though */
> + if (be16_to_cpu(we_mask->mask_length) != 4) {
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_MASK_LENGTH);
> + goto out;
> + }
> +
> + /* keep track of the guest's capability masks */
> + set_guest_receive_mask(be32_to_cpu(we_mask->cp_receive_mask));
> +
> + /* return the SCLP's capability masks to the guest */
> + we_mask->send_mask = cpu_to_be32(get_host_send_mask());
> + we_mask->receive_mask = cpu_to_be32(get_host_receive_mask());
> +
> + sccb->h.response_code = cpu_to_be32(SCLP_RC_NORMAL_COMPLETION);
> +
> +out:
> + return 0;
> +}
> +
> +/* qemu object creation and initialization functions */
> +
> +#define TYPE_SCLP_EVENTS_BUS "s390-sclp-events-bus"
> +#define SCLP_EVENTS_BUS(obj) OBJECT_CHECK(SCLPS390Bus, (obj),\
> + TYPE_SCLP_EVENTS_BUS)
> +
> +static void sclp_events_bus_class_init(ObjectClass *klass, void *data)
> +{
> +}
> +
> +static const TypeInfo s390_sclp_events_bus_info = {
> + .name = TYPE_SCLP_EVENTS_BUS,
> + .parent = TYPE_BUS,
> + .instance_size = sizeof(SCLPS390Bus),
> + .class_init = sclp_events_bus_class_init,
> +};
> +
> +static int command_handler(SCCB *sccb, uint64_t code)
> +{
> + int r = 0;
> +
> + switch (code) {
> + case SCLP_CMD_READ_EVENT_DATA:
> + r = read_event_data(sccb);
> + break;
> + case SCLP_CMD_WRITE_EVENT_DATA:
> + r = write_event_data(sccb);
> + break;
> + case SCLP_CMD_WRITE_EVENT_MASK:
> + r = write_event_mask(sccb);
> + break;
> + default:
> +#ifdef DEBUG_HELPER
> + printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
> +#endif
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
> + break;
> + }
> + return r;
> +}
> +
> +static int init_event_facility(S390SCLPDevice *sdev)
> +{
> + SCLPEventFacility *event_facility;
> +
> + event_facility = g_malloc0(sizeof(SCLPEventFacility));
> + sdev->instance = event_facility;
> + sdev->sclp_command_handler = command_handler;
> + sdev->event_pending = event_pending;
> +
> + /* Spawn a new sclp-events facility */
> + qbus_create_inplace(&event_facility->sbus.qbus,
> + TYPE_SCLP_EVENTS_BUS, (DeviceState *)sdev, NULL);
> + event_facility->sbus.qbus.allow_hotplug = 0;
> + event_facility->sbus.event_facility = event_facility;
> + event_facility->qdev = (DeviceState *) sdev;
> +
> +
> + return 0;
> +}
> +
> +static void init_event_facility_class(ObjectClass *klass, void *data)
> +{
> + S390SCLPDeviceClass *k = SCLP_S390_DEVICE_CLASS(klass);
> +
> + k->init = init_event_facility;
> +}
> +
> +static TypeInfo s390_sclp_event_facility_info = {
> + .name = "s390-sclp-event-facility",
> + .parent = TYPE_DEVICE_S390_SCLP,
> + .instance_size = sizeof(S390SCLPDevice),
> + .class_init = init_event_facility_class,
> +};
> +
> +static int event_qdev_init(DeviceState *qdev)
> +{
> + SCLPEvent *event = DO_UPCAST(SCLPEvent, qdev, qdev);
> + SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event);
> +
> + return child->init(event);
> +}
> +
> +static int event_qdev_exit(DeviceState *qdev)
> +{
> + SCLPEvent *event = DO_UPCAST(SCLPEvent, qdev, qdev);
> + SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event);
> + if (child->exit) {
> + child->exit(event);
> + }
> + return 0;
> +}
> +
> +static void event_class_init(ObjectClass *klass, void *data)
> +{
> + DeviceClass *dc = DEVICE_CLASS(klass);
> +
> + dc->bus_type = TYPE_SCLP_EVENTS_BUS;
> + dc->unplug = qdev_simple_unplug_cb;
> + dc->init = event_qdev_init;
> + dc->exit = event_qdev_exit;
> +}
> +
> +static TypeInfo s390_sclp_event_type_info = {
> + .name = TYPE_SCLP_EVENT,
> + .parent = TYPE_DEVICE,
> + .instance_size = sizeof(SCLPEvent),
> + .class_init = event_class_init,
> + .class_size = sizeof(SCLPEventClass),
> + .abstract = true,
> +};
> +
> +static void register_types(void)
> +{
> + type_register_static(&s390_sclp_events_bus_info);
> + type_register_static(&s390_sclp_event_facility_info);
> + type_register_static(&s390_sclp_event_type_info);
> +}
> +type_init(register_types)
> diff --git a/hw/s390-event-facility.h b/hw/s390-event-facility.h
> new file mode 100644
> index 0000000..938fb4b
> --- /dev/null
> +++ b/hw/s390-event-facility.h
> @@ -0,0 +1,107 @@
> +/*
> + * SCLP
> + * Event Facility definitions
> + *
> + * Copyright IBM, Corp. 2007, 2012
> + *
> + * Authors:
> + * Heinz Graalfs <graalfs@de.ibm.com>
> + *
> + * This work is licensed under the terms of the GNU GPL, version 2. See
> + * the COPYING file in the top-level directory.
> + *
> + */
> +
> +#ifndef _QEMU_S390_SCLP_EVENT_FACILITY_H
> +#define _QEMU_S390_SCLP_EVENT_FACILITY_H
> +
> +#include "qdev.h"
> +#include "qemu-thread.h"
> +
> +/* SCLP event types */
> +#define SCLP_EVENT_ASCII_CONSOLE_DATA 0x1a
> +#define SCLP_EVENT_SIGNAL_QUIESCE 0x1d
> +
> +/* SCLP event masks */
> +#define SCLP_EVENT_MASK_SIGNAL_QUIESCE 0x00000008
> +#define SCLP_EVENT_MASK_MSG_ASCII 0x00000040
> +
> +#define SCLP_UNCONDITIONAL_READ 0x00
> +#define SCLP_SELECTIVE_READ 0x01
> +
> +#define TYPE_SCLP_EVENT "s390-sclp-event-type"
> +#define SCLP_EVENT(obj) \
> + OBJECT_CHECK(SCLPEvent, (obj), TYPE_SCLP_EVENT)
> +#define SCLP_EVENT_CLASS(klass) \
> + OBJECT_CLASS_CHECK(SCLPEventClass, (klass), TYPE_SCLP_EVENT)
> +#define SCLP_EVENT_GET_CLASS(obj) \
> + OBJECT_GET_CLASS(SCLPEventClass, (obj), TYPE_SCLP_EVENT)
> +
> +typedef struct WriteEventMask {
> + SCCBHeader h;
> + uint16_t _reserved;
> + uint16_t mask_length;
> + uint32_t cp_receive_mask;
> + uint32_t cp_send_mask;
> + uint32_t send_mask;
> + uint32_t receive_mask;
> +} __attribute__((packed)) WriteEventMask;
QEMU_PACKED, also below.
> +
> +typedef struct EventBufferHeader {
> + uint16_t length;
> + uint8_t type;
> + uint8_t flags;
> + uint16_t _reserved;
> +} __attribute__((packed)) EventBufferHeader;
> +
> +typedef struct WriteEventData {
> + SCCBHeader h;
> + EventBufferHeader ebh;
> +} __attribute__((packed)) WriteEventData;
> +
> +typedef struct ReadEventData {
> + SCCBHeader h;
> + EventBufferHeader ebh;
> + uint32_t mask;
> +} __attribute__((packed)) ReadEventData;
> +
> +typedef struct SCLPEvent {
> + DeviceState qdev;
> + QemuMutex lock;
> + bool event_pending;
> + uint32_t event_type;
> + char *name;
> +} SCLPEvent;
> +
> +typedef struct SCLPEventClass {
> + DeviceClass parent_class;
> + int (*init)(SCLPEvent *event);
> + int (*exit)(SCLPEvent *event);
> +
> + /* get SCLP's send mask */
> + unsigned int (*get_send_mask)(void);
> +
> + /* get SCLP's receive mask */
> + unsigned int (*get_receive_mask)(void);
> +
> + int (*read_event_data)(SCLPEvent *event, EventBufferHeader *evt_buf_hdr,
> + int *slen);
> +
> + int (*write_event_data)(SCLPEvent *event, EventBufferHeader *evt_buf_hdr);
> +
> + /* returns the supported event type */
> + int (*event_type)(void);
> +
> +} SCLPEventClass;
> +
> +static inline void lock(SCLPEvent *event)
> +{
> + qemu_mutex_lock(&event->lock);
> +}
> +
> +static inline void unlock(SCLPEvent *event)
> +{
> + qemu_mutex_unlock(&event->lock);
> +}
> +
> +#endif
> diff --git a/hw/s390-sclp.c b/hw/s390-sclp.c
> index 74a3e66..4ee04b1 100644
> --- a/hw/s390-sclp.c
> +++ b/hw/s390-sclp.c
> @@ -44,10 +44,7 @@ static int sclp_execute(SCCB *sccb, uint64_t code)
> r = read_SCP_info(sccb);
> break;
> default:
> -#ifdef DEBUG_HELPER
> - printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
> -#endif
> - sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
> + r = sclp_bus->event_facility->sclp_command_handler(sccb, code);
> break;
> }
> return r;
> @@ -88,10 +85,12 @@ out:
>
> void sclp_service_interrupt(uint32_t sccb)
> {
> - if (!sccb) {
> + int event_pending = sclp_bus->event_facility->event_pending();
> +
> + if (!event_pending && !sccb) {
> return;
> }
> - s390_sclp_extint(sccb & ~3);
> + s390_sclp_extint((sccb & ~3) + event_pending);
> }
>
> /* qemu object creation and initialization functions */
> @@ -115,6 +114,9 @@ SCLPS390Bus *s390_sclp_bus_init(void)
> bus_state = qbus_create(TYPE_S390_SCLP_BUS, dev, "s390-sclp-bus");
> bus_state->allow_hotplug = 0;
>
> + dev = qdev_create(bus_state, "s390-sclp-event-facility");
> + qdev_init_nofail(dev);
> +
> bus = DO_UPCAST(SCLPS390Bus, bus, bus_state);
> return bus;
> }
> @@ -140,9 +142,44 @@ static TypeInfo s390_sclp_bridge_info = {
> .class_init = s390_sclp_bridge_class_init,
> };
>
> +static int s390_sclp_busdev_init(DeviceState *dev)
> +{
> + int r;
> + S390SCLPDevice *sdev = (S390SCLPDevice *)dev;
> + S390SCLPDeviceClass *sclp = SCLP_S390_DEVICE_GET_CLASS(dev);
> + SCLPS390Bus *bus = DO_UPCAST(SCLPS390Bus, bus, sdev->qdev.parent_bus);
> +
> + r = sclp->init(sdev);
> + if (!r) {
> + assert(sdev->event_pending);
> + assert(sdev->sclp_command_handler);
> + }
> + bus->event_facility = sdev;
> +
> + return r;
> +}
> +
> +static void s390_sclp_device_class_init(ObjectClass *klass, void *data)
> +{
> + DeviceClass *dc = DEVICE_CLASS(klass);
> +
> + dc->init = s390_sclp_busdev_init;
> + dc->bus_type = TYPE_S390_SCLP_BUS;
> +}
> +
> +static TypeInfo s390_sclp_device_info = {
> + .name = TYPE_DEVICE_S390_SCLP,
> + .parent = TYPE_DEVICE,
> + .instance_size = sizeof(S390SCLPDevice),
> + .class_init = s390_sclp_device_class_init,
> + .class_size = sizeof(S390SCLPDeviceClass),
> + .abstract = true,
> +};
> +
> static void s390_sclp_register_types(void)
> {
> type_register_static(&s390_sclp_bridge_info);
> type_register_static(&s390_sclp_bus_info);
> + type_register_static(&s390_sclp_device_info);
> }
> type_init(s390_sclp_register_types)
> diff --git a/hw/s390-sclp.h b/hw/s390-sclp.h
> index f7bf140..24014eb 100644
> --- a/hw/s390-sclp.h
> +++ b/hw/s390-sclp.h
> @@ -19,15 +19,35 @@
> /* SCLP command codes */
> #define SCLP_CMDW_READ_SCP_INFO 0x00020001
> #define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
> +#define SCLP_CMD_READ_EVENT_DATA 0x00770005
> +#define SCLP_CMD_WRITE_EVENT_DATA 0x00760005
> +#define SCLP_CMD_READ_EVENT_DATA 0x00770005
> +#define SCLP_CMD_WRITE_EVENT_DATA 0x00760005
> +#define SCLP_CMD_WRITE_EVENT_MASK 0x00780005
>
> /* SCLP response codes */
> #define SCLP_RC_NORMAL_READ_COMPLETION 0x0010
> +#define SCLP_RC_NORMAL_COMPLETION 0x0020
> #define SCLP_RC_INVALID_SCLP_COMMAND 0x01f0
> +#define SCLP_RC_CONTAINED_EQUIPMENT_CHECK 0x0340
> +#define SCLP_RC_INSUFFICIENT_SCCB_LENGTH 0x0300
> +#define SCLP_RC_INVALID_FUNCTION 0x40f0
> +#define SCLP_RC_NO_EVENT_BUFFERS_STORED 0x60f0
> +#define SCLP_RC_INVALID_SELECTION_MASK 0x70f0
> +#define SCLP_RC_INCONSISTENT_LENGTHS 0x72f0
> +#define SCLP_RC_EVENT_BUFFER_SYNTAX_ERROR 0x73f0
> +#define SCLP_RC_INVALID_MASK_LENGTH 0x74f0
> +
>
> /* Service Call Control Block (SCCB) and its elements */
>
> #define SCCB_SIZE 4096
>
> +#define SCLP_VARIABLE_LENGTH_RESPONSE 0x80
> +#define SCLP_EVENT_BUFFER_ACCEPTED 0x80
> +
> +#define SCLP_FC_NORMAL_WRITE 0
> +
> /*
> * Normally packed structures are not the right thing to do, since all code
> * must take care of endianess. We cant use ldl_phys and friends for two
> @@ -63,14 +83,37 @@ typedef struct SCCB {
>
> #define TYPE_S390_SCLP_BUS "s390-sclp-bus"
>
> +#define TYPE_DEVICE_S390_SCLP "s390-sclp-device"
> +#define SCLP_S390_DEVIVE(obj) \
> + OBJECT_CHECK(S390SCLPDevice, (obj), TYPE_DEVICE_S390_SCLP)
> +#define SCLP_S390_DEVICE_CLASS(klass) \
> + OBJECT_CLASS_CHECK(S390SCLPDeviceClass, (klass), \
> + TYPE_DEVICE_S390_SCLP)
> +#define SCLP_S390_DEVICE_GET_CLASS(obj) \
> + OBJECT_GET_CLASS(S390SCLPDeviceClass, (obj), \
> + TYPE_DEVICE_S390_SCLP)
> +
> +typedef struct SCLPEventFacility SCLPEventFacility;
> +
> typedef struct S390SCLPDevice {
> DeviceState qdev;
> + SCLPEventFacility *instance;
> + int (*sclp_command_handler)(SCCB *sccb, uint64_t code);
> + bool (*event_pending)(void);
> } S390SCLPDevice;
>
> typedef struct SCLPS390Bus {
> BusState bus;
> + S390SCLPDevice *event_facility;
> } SCLPS390Bus;
>
> +typedef struct S390SCLPDeviceClass {
> + DeviceClass qdev;
> +
> + int (*init)(S390SCLPDevice *sdev);
> +
> +} S390SCLPDeviceClass;
> +
> extern SCLPS390Bus *sclp_bus;
>
> SCLPS390Bus *s390_sclp_bus_init(void);
> diff --git a/hw/s390x/Makefile.objs b/hw/s390x/Makefile.objs
> index b2d577b..5ebde3b 100644
> --- a/hw/s390x/Makefile.objs
> +++ b/hw/s390x/Makefile.objs
> @@ -1,4 +1,4 @@
> obj-y = s390-virtio-bus.o s390-virtio.o
> -obj-y += s390-sclp.o
> +obj-y += s390-sclp.o s390-event-facility.o
>
> obj-y := $(addprefix ../,$(obj-y))
> --
> 1.7.10.5
>
>
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [Qemu-devel] [PATCH 2/6] s390: sclp base support
2012-07-13 15:08 ` Blue Swirl
@ 2012-07-13 16:44 ` Christian Borntraeger
2012-07-14 8:48 ` Blue Swirl
0 siblings, 1 reply; 14+ messages in thread
From: Christian Borntraeger @ 2012-07-13 16:44 UTC (permalink / raw)
To: Blue Swirl
Cc: Cornelia Huck, Jens Freimann, Heinz Graalfs, Alexander Graf, qemu-devel
Thanks fpr the review,
On 13/07/12 17:08, Blue Swirl wrote:
>> + * Copyright IBM, Corp. 2007, 2012
>
> 2007, really?
Well, yes and no. The first userspace for kvm on s390 was kuli and some of that
code was used for bringup. But it looks pretty different now, so we can
change that to be 2012 as the first release.
[...]
>> + * This work is licensed under the terms of the GNU GPL, version 2. See
>
> Why GPLv2only, can't this be licensed under later versions?
Was simply copied from other qemu files. We can certainly change that to 2 and later.
[...]
>> +int do_sclp_service_call(uint32_t sccb, uint64_t code)
>
> sccb could be target_phys_addr_t.
the architecture explicitely requires to have the 32 msbs to be 0. target_phys_addr_t
would certainly work as well, but
[...]
>> + cpu_physical_memory_write(sccb, &work_sccb,
>> + be16_to_cpu(work_sccb.h.length));
>
> Perhaps the DMA helpers should be used instead.
>
Is there any rule what to use under which circumstances.
[...]
>> +#ifndef _QEMU_S390_SCLP_H
>> +#define _QEMU_S390_SCLP_H
>
> HW_S390_SCLP_H
Ok
[...]
>> +} __attribute__((packed)) SCCBHeader;
>
> QEMU_PACKED
Ok
[...]
>> +extern SCLPS390Bus *sclp_bus;
>
> Global state is suspicious, usually it can be avoided with parameter passing.
[...]
Will check if we can make that go away.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [Qemu-devel] [PATCH 2/6] s390: sclp base support
2012-07-13 16:44 ` Christian Borntraeger
@ 2012-07-14 8:48 ` Blue Swirl
2012-07-16 7:04 ` Christian Borntraeger
0 siblings, 1 reply; 14+ messages in thread
From: Blue Swirl @ 2012-07-14 8:48 UTC (permalink / raw)
To: Christian Borntraeger
Cc: Cornelia Huck, Jens Freimann, Heinz Graalfs, Alexander Graf, qemu-devel
On Fri, Jul 13, 2012 at 4:44 PM, Christian Borntraeger
<borntraeger@de.ibm.com> wrote:
> Thanks fpr the review,
>
>
> On 13/07/12 17:08, Blue Swirl wrote:
>
>>> + * Copyright IBM, Corp. 2007, 2012
>>
>> 2007, really?
>
> Well, yes and no. The first userspace for kvm on s390 was kuli and some of that
> code was used for bringup. But it looks pretty different now, so we can
> change that to be 2012 as the first release.
>
> [...]
>>> + * This work is licensed under the terms of the GNU GPL, version 2. See
>>
>> Why GPLv2only, can't this be licensed under later versions?
>
> Was simply copied from other qemu files. We can certainly change that to 2 and later.
Great!
>
>
> [...]
>
>>> +int do_sclp_service_call(uint32_t sccb, uint64_t code)
>>
>> sccb could be target_phys_addr_t.
>
> the architecture explicitely requires to have the 32 msbs to be 0. target_phys_addr_t
> would certainly work as well, but
>
> [...]
>>> + cpu_physical_memory_write(sccb, &work_sccb,
>>> + be16_to_cpu(work_sccb.h.length));
>>
>> Perhaps the DMA helpers should be used instead.
>>
>
> Is there any rule what to use under which circumstances.
No, it's a recent addition. Devices (at least those which may be used
in IOMMU environment) should use DMA helpers for their memory accesses
in general but virtio may be an exception. I'm not sure which category
this falls in.
>
>
> [...]
>>> +#ifndef _QEMU_S390_SCLP_H
>>> +#define _QEMU_S390_SCLP_H
>>
>> HW_S390_SCLP_H
>
> Ok
>
> [...]
>>> +} __attribute__((packed)) SCCBHeader;
>>
>> QEMU_PACKED
>
> Ok
>
> [...]
>>> +extern SCLPS390Bus *sclp_bus;
>>
>> Global state is suspicious, usually it can be avoided with parameter passing.
> [...]
>
> Will check if we can make that go away.
>
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [Qemu-devel] [PATCH 2/6] s390: sclp base support
2012-07-14 8:48 ` Blue Swirl
@ 2012-07-16 7:04 ` Christian Borntraeger
0 siblings, 0 replies; 14+ messages in thread
From: Christian Borntraeger @ 2012-07-16 7:04 UTC (permalink / raw)
To: Blue Swirl
Cc: Cornelia Huck, Jens Freimann, Heinz Graalfs, Alexander Graf, qemu-devel
On 14/07/12 10:48, Blue Swirl wrote:
>>>> + cpu_physical_memory_write(sccb, &work_sccb,
>>>> + be16_to_cpu(work_sccb.h.length));
>>>
>>> Perhaps the DMA helpers should be used instead.
>>>
>>
>> Is there any rule what to use under which circumstances.
>
> No, it's a recent addition. Devices (at least those which may be used
> in IOMMU environment) should use DMA helpers for their memory accesses
> in general but virtio may be an exception. I'm not sure which category
> this falls in.
Ok, I read this as, if we need to handle DMA into virtual addresses at some
point in time dma helpers are the way to go.
With SCLP we access real storage (no translation) so I think
cpu_physical_memory_write is fine here.
Christian
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [Qemu-devel] [PATCH 2/6] s390: sclp base support
2012-07-13 10:52 ` [Qemu-devel] [PATCH 2/6] s390: sclp base support Christian Borntraeger
2012-07-13 15:08 ` Blue Swirl
@ 2012-07-20 14:06 ` Andreas Färber
2012-07-23 11:05 ` Christian Borntraeger
1 sibling, 1 reply; 14+ messages in thread
From: Andreas Färber @ 2012-07-20 14:06 UTC (permalink / raw)
To: Christian Borntraeger
Cc: Cornelia Huck, Jens Freimann, Heinz Graalfs, Alexander Graf, qemu-devel
Am 13.07.2012 12:52, schrieb Christian Borntraeger:
> From: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
>
> This adds a more generic infrastructure for handling Service-Call
> requests on s390. Currently we only support a small subset of Read
> SCP Info directly in target-s390x. This patch provides the base
> infrastructure for supporting more commands and moves Read SCP
> Info.
> In the future we could add additional commands for hotplug, call
> home and event handling.
>
> Signed-off-by: Heinz Graalfs <graalfs@linux.vnet.ibm.com>
> Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
> ---
> hw/s390-sclp.c | 148 ++++++++++++++++++++++++++++++++++++++++++++++
> hw/s390-sclp.h | 80 +++++++++++++++++++++++++
> hw/s390-virtio.c | 3 +
> hw/s390x/Makefile.objs | 1 +
> target-s390x/cpu.c | 17 ++++++
> target-s390x/cpu.h | 18 ++----
> target-s390x/kvm.c | 5 +-
> target-s390x/op_helper.c | 45 ++------------
> 8 files changed, 261 insertions(+), 56 deletions(-)
> create mode 100644 hw/s390-sclp.c
> create mode 100644 hw/s390-sclp.h
>
> diff --git a/hw/s390-sclp.c b/hw/s390-sclp.c
> new file mode 100644
> index 0000000..74a3e66
> --- /dev/null
> +++ b/hw/s390-sclp.c
> @@ -0,0 +1,148 @@
> +/*
> + * SCLP Support
> + *
> + * Copyright IBM, Corp. 2007, 2012
> + *
> + * Authors:
> + * Christian Borntraeger <borntraeger@de.ibm.com>
> + * Heinz Graalfs <graalfs@linux.vnet.ibm.com>
> + *
> + * This work is licensed under the terms of the GNU GPL, version 2. See
> + * the COPYING file in the top-level directory.
> + *
> + */
> +
> +#include "cpu.h"
> +#include "kvm.h"
> +#include "sysbus.h"
> +
> +#include "s390-sclp.h"
> +
> +/* Provide information about the configuration, CPUs and storage */
> +static int read_SCP_info(SCCB *sccb)
> +{
> + ReadInfo *read_info = (ReadInfo *) sccb;
> + int shift = 0;
> +
> + while ((ram_size >> (20 + shift)) > 65535) {
> + shift++;
> + }
> + read_info->rnmax = cpu_to_be16(ram_size >> (20 + shift));
> + read_info->rnsize = 1 << shift;
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
> +
> + return 0;
> +}
> +
> +static int sclp_execute(SCCB *sccb, uint64_t code)
> +{
> + int r = 0;
> +
> + switch (code) {
> + case SCLP_CMDW_READ_SCP_INFO:
> + case SCLP_CMDW_READ_SCP_INFO_FORCED:
> + r = read_SCP_info(sccb);
> + break;
> + default:
> +#ifdef DEBUG_HELPER
> + printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
sccb is a pointer so %x seems wrong for 64-bit host. %p?
> +#endif
> + sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
> + break;
> + }
> + return r;
> +}
> +
> +int do_sclp_service_call(uint32_t sccb, uint64_t code)
> +{
> + int r = 0;
> + SCCB work_sccb;
> +
> + target_phys_addr_t sccb_len = sizeof(SCCB);
> +
> + /*
> + * we want to work on a private copy of the sccb, to prevent guests
> + * from playing dirty tricks by modifying the memory content after
> + * the host has checked the values
> + */
> + cpu_physical_memory_read(sccb, &work_sccb, sccb_len);
> +
> + /* Valid sccb sizes */
> + if (be16_to_cpu(work_sccb.h.length) < 8 ||
> + be16_to_cpu(work_sccb.h.length) > 4096) {
> + r = -PGM_SPECIFICATION;
> + goto out;
> + }
> +
> + r = sclp_execute((SCCB *)&work_sccb, code);
> +
> + cpu_physical_memory_write(sccb, &work_sccb,
> + be16_to_cpu(work_sccb.h.length));
> + if (!r) {
> + sclp_service_interrupt(sccb);
> + }
> +
> +out:
> + return r;
> +}
> +
> +void sclp_service_interrupt(uint32_t sccb)
> +{
> + if (!sccb) {
> + return;
> + }
> + s390_sclp_extint(sccb & ~3);
> +}
> +
> +/* qemu object creation and initialization functions */
> +
> +#define S390_SCLP_BUS(obj) OBJECT_CHECK(SCLPS390Bus, (obj), TYPE_S390_SCLP_BUS)
This should probably be in the header alongside TYPE_S390_SCLP_BUS?
Otherwise a separating white line would be nice.
> +static const TypeInfo s390_sclp_bus_info = {
> + .name = TYPE_S390_SCLP_BUS,
> + .parent = TYPE_BUS,
> + .instance_size = sizeof(SCLPS390Bus),
> + };
> +
> +SCLPS390Bus *s390_sclp_bus_init(void)
> +{
> + SCLPS390Bus *bus;
> + BusState *bus_state;
> + DeviceState *dev;
> +
> + dev = qdev_create(NULL, "s390-sclp-bridge");
> + qdev_init_nofail(dev);
> +
> + bus_state = qbus_create(TYPE_S390_SCLP_BUS, dev, "s390-sclp-bus");
Use TYPE_S390_SCLP_BUS constant?
> + bus_state->allow_hotplug = 0;
> +
> + bus = DO_UPCAST(SCLPS390Bus, bus, bus_state);
> + return bus;
> +}
> +
> +static int s390_sclp_bridge_init(SysBusDevice *dev)
> +{
> + return 0;
> +}
> +
> +static void s390_sclp_bridge_class_init(ObjectClass *klass, void *data)
> +{
> + DeviceClass *dc = DEVICE_CLASS(klass);
> + SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
> +
> + k->init = s390_sclp_bridge_init;
> + dc->no_user = 1;
> +}
> +
> +static TypeInfo s390_sclp_bridge_info = {
> + .name = "s390-sclp-bridge",
> + .parent = TYPE_SYS_BUS_DEVICE,
> + .instance_size = sizeof(SysBusDevice),
> + .class_init = s390_sclp_bridge_class_init,
> +};
> +
> +static void s390_sclp_register_types(void)
> +{
> + type_register_static(&s390_sclp_bridge_info);
> + type_register_static(&s390_sclp_bus_info);
> +}
> +type_init(s390_sclp_register_types)
> diff --git a/hw/s390-sclp.h b/hw/s390-sclp.h
> new file mode 100644
> index 0000000..f7bf140
> --- /dev/null
> +++ b/hw/s390-sclp.h
> @@ -0,0 +1,80 @@
> +/*
> + * SCLP Support
> + *
> + * Copyright IBM, Corp. 2007, 2012
> + *
> + * Authors:
> + * Christian Borntraeger <borntraeger@de.ibm.com>
> + *
> + * This work is licensed under the terms of the GNU GPL, version 2. See
> + * the COPYING file in the top-level directory.
> + *
> + */
> +
> +#ifndef _QEMU_S390_SCLP_H
> +#define _QEMU_S390_SCLP_H
> +
> +#include "qdev.h"
> +
> +/* SCLP command codes */
> +#define SCLP_CMDW_READ_SCP_INFO 0x00020001
> +#define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
> +
> +/* SCLP response codes */
> +#define SCLP_RC_NORMAL_READ_COMPLETION 0x0010
> +#define SCLP_RC_INVALID_SCLP_COMMAND 0x01f0
> +
> +/* Service Call Control Block (SCCB) and its elements */
> +
> +#define SCCB_SIZE 4096
> +
> +/*
> + * Normally packed structures are not the right thing to do, since all code
> + * must take care of endianess. We cant use ldl_phys and friends for two
> + * reasons, though:
> + * - some of the embedded structures below the SCCB can appear multiple times
> + * at different locations, so there is no fixed offset
> + * - we work on a private copy of the SCCB, since there are several length
> + * fields, that would cause a security nightmare if we allow the guest to
> + * alter the structure while we parse it. We cannot use ldl_p and friends
> + * either without doing pointer arithmetics
> + * So we have to double check that all users of sclp data structures use the
> + * right endianess wrappers.
> + */
> +typedef struct SCCBHeader {
> + uint16_t length;
> + uint8_t function_code;
> + uint8_t control_mask[3];
> + uint16_t response_code;
> +} __attribute__((packed)) SCCBHeader;
> +
> +#define SCCB_DATA_LEN (SCCB_SIZE - sizeof(SCCBHeader))
> +
> +typedef struct ReadInfo {
> + SCCBHeader h;
> + uint16_t rnmax;
> + uint8_t rnsize;
> +} __attribute__((packed)) ReadInfo;
> +
> +typedef struct SCCB {
> + SCCBHeader h;
> + char data[SCCB_DATA_LEN];
> + } __attribute__((packed)) SCCB;
> +
> +#define TYPE_S390_SCLP_BUS "s390-sclp-bus"
> +
> +typedef struct S390SCLPDevice {
> + DeviceState qdev;
I note that this is probably the first device directly derived from
DeviceState. This should be possible now after having merged the QOM
QBus series. Test case to check is "info qdm" from the monitor.
> +} S390SCLPDevice;
> +
> +typedef struct SCLPS390Bus {
> + BusState bus;
> +} SCLPS390Bus;
> +
> +extern SCLPS390Bus *sclp_bus;
> +
> +SCLPS390Bus *s390_sclp_bus_init(void);
> +
> +void sclp_service_interrupt(uint32_t sccb);
> +
> +#endif
> diff --git a/hw/s390-virtio.c b/hw/s390-virtio.c
> index 47eed35..577fcee 100644
> --- a/hw/s390-virtio.c
> +++ b/hw/s390-virtio.c
> @@ -32,6 +32,7 @@
> #include "exec-memory.h"
>
> #include "hw/s390-virtio-bus.h"
> +#include "hw/s390-sclp.h"
>
> //#define DEBUG_S390
>
> @@ -61,6 +62,7 @@
> #define MAX_BLK_DEVS 10
>
> static VirtIOS390Bus *s390_bus;
> +SCLPS390Bus *sclp_bus;
I don't like this so much. We shouldn't be following that example and
adding global state for each bus there. Can't we add a child property to
the machine for the hosting device so that we can obtain that via QOM
path and access the bus from there?
> static S390CPU **ipi_states;
>
> S390CPU *s390_cpu_addr2state(uint16_t cpu_addr)
> @@ -183,6 +185,7 @@ static void s390_init(ram_addr_t my_ram_size,
>
> /* get a BUS */
> s390_bus = s390_virtio_bus_init(&my_ram_size);
> + sclp_bus = s390_sclp_bus_init();
>
> /* allocate RAM */
> memory_region_init_ram(ram, "s390.ram", my_ram_size);
> diff --git a/hw/s390x/Makefile.objs b/hw/s390x/Makefile.objs
> index dcdcac8..b2d577b 100644
> --- a/hw/s390x/Makefile.objs
> +++ b/hw/s390x/Makefile.objs
> @@ -1,3 +1,4 @@
> obj-y = s390-virtio-bus.o s390-virtio.o
> +obj-y += s390-sclp.o
>
> obj-y := $(addprefix ../,$(obj-y))
IIUC we have a dependency on the CPU inside the device code. If so,
please move the s390-sclp.c file into hw/s390x/ and move the obj-y +=
line below the addprefix line.
> diff --git a/target-s390x/cpu.c b/target-s390x/cpu.c
> index 619b202..8900872 100644
> --- a/target-s390x/cpu.c
> +++ b/target-s390x/cpu.c
> @@ -21,9 +21,26 @@
> */
>
> #include "cpu.h"
> +#include "kvm.h"
> #include "qemu-common.h"
> #include "qemu-timer.h"
>
> +/* service interrupts are floating therefore we must not pass an cpustate */
> +void s390_sclp_extint(uint32_t parm)
> +{
> + S390CPU *dummy_cpu = s390_cpu_addr2state(0);
> + CPUS390XState *env = &dummy_cpu->env;
> +
> + if (kvm_enabled()) {
> +#ifdef CONFIG_KVM
> + kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE, parm, 0, 1);
> +#endif
> + } else {
> + env->psw.addr += 4;
> + cpu_inject_ext(env, EXT_SERVICE, parm, 0);
> + }
> +}
Not so happy about this placement, it is not called s390_cpu_, the
prototype is in cpu.h not cpu-qom.h and it operates only indirectly on
the CPU. Is there another place for it?
> +
>
> /* CPUClass::reset() */
> static void s390_cpu_reset(CPUState *s)
> diff --git a/target-s390x/cpu.h b/target-s390x/cpu.h
> index c30ac3a..abdd838 100644
> --- a/target-s390x/cpu.h
> +++ b/target-s390x/cpu.h
> @@ -294,6 +294,7 @@ void s390x_tod_timer(void *opaque);
> void s390x_cpu_timer(void *opaque);
>
> int s390_virtio_hypercall(CPUS390XState *env, uint64_t mem, uint64_t hypercall);
> +int do_sclp_service_call(uint32_t sccb, uint64_t code);
>
> #ifdef CONFIG_KVM
> void kvm_s390_interrupt(CPUS390XState *env, int type, uint32_t code);
> @@ -315,11 +316,15 @@ static inline void kvm_s390_interrupt_internal(CPUS390XState *env, int type,
> int vm)
> {
> }
> +
> #endif
Stray whitespace change? If we want to do it, we might want to add one
after #endif as well and after #ifdef in the preceding hunk.
Regards,
Andreas
> S390CPU *s390_cpu_addr2state(uint16_t cpu_addr);
> void s390_add_running_cpu(CPUS390XState *env);
> unsigned s390_del_running_cpu(CPUS390XState *env);
>
> +/* service interrupts are floating therefore we must not pass an cpustate */
> +void s390_sclp_extint(uint32_t parm);
> +
> /* from s390-virtio-bus */
> extern const target_phys_addr_t virtio_size;
>
> @@ -593,17 +598,6 @@ static inline const char *cc_name(int cc_op)
> return cc_names[cc_op];
> }
>
> -/* SCLP PV interface defines */
> -#define SCLP_CMDW_READ_SCP_INFO 0x00020001
> -#define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
> -
> -#define SCP_LENGTH 0x00
> -#define SCP_FUNCTION_CODE 0x02
> -#define SCP_CONTROL_MASK 0x03
> -#define SCP_RESPONSE_CODE 0x06
> -#define SCP_MEM_CODE 0x08
> -#define SCP_INCREMENT 0x0a
> -
> typedef struct LowCore
> {
> /* prefix area: defined by architecture */
> @@ -952,7 +946,7 @@ static inline void ebcdic_put(uint8_t *p, const char *ascii, int len)
> void load_psw(CPUS390XState *env, uint64_t mask, uint64_t addr);
> int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
> target_ulong *raddr, int *flags);
> -int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code);
> +int sclp_service_call(uint32_t sccb, uint64_t code);
> uint32_t calc_cc(CPUS390XState *env, uint32_t cc_op, uint64_t src, uint64_t dst,
> uint64_t vr);
>
> diff --git a/target-s390x/kvm.c b/target-s390x/kvm.c
> index 654f87d..68c4f3e 100644
> --- a/target-s390x/kvm.c
> +++ b/target-s390x/kvm.c
> @@ -60,9 +60,6 @@
> #define SIGP_STORE_STATUS_ADDR 0x0e
> #define SIGP_SET_ARCH 0x12
>
> -#define SCLP_CMDW_READ_SCP_INFO 0x00020001
> -#define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
> -
> const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
> KVM_CAP_LAST_INFO
> };
> @@ -237,7 +234,7 @@ static int kvm_sclp_service_call(CPUS390XState *env, struct kvm_run *run,
> sccb = env->regs[ipbh0 & 0xf];
> code = env->regs[(ipbh0 & 0xf0) >> 4];
>
> - r = sclp_service_call(env, sccb, code);
> + r = sclp_service_call(sccb, code);
> if (r < 0) {
> enter_pgmcheck(env, -r);
> }
> diff --git a/target-s390x/op_helper.c b/target-s390x/op_helper.c
> index 91dd8dc..e7bb980 100644
> --- a/target-s390x/op_helper.c
> +++ b/target-s390x/op_helper.c
> @@ -2362,20 +2362,12 @@ static void program_interrupt(CPUS390XState *env, uint32_t code, int ilc)
> }
> }
>
> -static void ext_interrupt(CPUS390XState *env, int type, uint32_t param,
> - uint64_t param64)
> -{
> - cpu_inject_ext(env, type, param, param64);
> -}
> -
> /*
> + * we handle here the part that belongs to the cpu, e.g. program checks
> * ret < 0 indicates program check, ret = 0,1,2,3 -> cc
> */
> -int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code)
> +int sclp_service_call(uint32_t sccb, uint64_t code)
> {
> - int r = 0;
> - int shift = 0;
> -
> #ifdef DEBUG_HELPER
> printf("sclp(0x%x, 0x%" PRIx64 ")\n", sccb, code);
> #endif
> @@ -2388,35 +2380,8 @@ int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code)
> return -PGM_SPECIFICATION;
> }
>
> - switch(code) {
> - case SCLP_CMDW_READ_SCP_INFO:
> - case SCLP_CMDW_READ_SCP_INFO_FORCED:
> - while ((ram_size >> (20 + shift)) > 65535) {
> - shift++;
> - }
> - stw_phys(sccb + SCP_MEM_CODE, ram_size >> (20 + shift));
> - stb_phys(sccb + SCP_INCREMENT, 1 << shift);
> - stw_phys(sccb + SCP_RESPONSE_CODE, 0x10);
> -
> - if (kvm_enabled()) {
> -#ifdef CONFIG_KVM
> - kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE,
> - sccb & ~3, 0, 1);
> -#endif
> - } else {
> - env->psw.addr += 4;
> - ext_interrupt(env, EXT_SERVICE, sccb & ~3, 0);
> - }
> - break;
> - default:
> -#ifdef DEBUG_HELPER
> - printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
> -#endif
> - r = 3;
> - break;
> - }
> -
> - return r;
> + /* the complex part is handled by external components */
> + return do_sclp_service_call(sccb, code);
> }
>
> /* SCLP service call */
> @@ -2424,7 +2389,7 @@ uint32_t HELPER(servc)(uint32_t r1, uint64_t r2)
> {
> int r;
>
> - r = sclp_service_call(env, r1, r2);
> + r = sclp_service_call(r1, r2);
> if (r < 0) {
> program_interrupt(env, -r, 4);
> return 0;
>
--
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg, Germany
GF: Jeff Hawn, Jennifer Guild, Felix Imendörffer; HRB 16746 AG Nürnberg
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [Qemu-devel] [PATCH 2/6] s390: sclp base support
2012-07-20 14:06 ` Andreas Färber
@ 2012-07-23 11:05 ` Christian Borntraeger
0 siblings, 0 replies; 14+ messages in thread
From: Christian Borntraeger @ 2012-07-23 11:05 UTC (permalink / raw)
To: Andreas Färber
Cc: Cornelia Huck, Jens Freimann, Heinz Graalfs, Alexander Graf, qemu-devel
Andreas,
thanks for having a look. I no other comments arrive today I will resubmit the patch
set with all comments addressed.
On 20/07/12 16:06, Andreas Färber wrote:
>> +#ifdef DEBUG_HELPER
>> + printf("KVM: invalid sclp call 0x%x / 0x%" PRIx64 "x\n", sccb, code);
>
> sccb is a pointer so %x seems wrong for 64-bit host. %p?
yes its broken.
We will probably just remove that, since it will be changed by followon patch.
>> +typedef struct S390SCLPDevice {
>> + DeviceState qdev;
>
> I note that this is probably the first device directly derived from
> DeviceState. This should be possible now after having merged the QOM
> QBus series. Test case to check is "info qdm" from the monitor.
info qdm seems to work. what test did you have in mind?
[...]
>> //#define DEBUG_S390
>>
>> @@ -61,6 +62,7 @@
>> #define MAX_BLK_DEVS 10
>>
>> static VirtIOS390Bus *s390_bus;
>> +SCLPS390Bus *sclp_bus;
>
> I don't like this so much. We shouldn't be following that example and
> adding global state for each bus there. Can't we add a child property to
> the machine for the hosting device so that we can obtain that via QOM
> path and access the bus from there?
Since Blue already compained Heinz already moved that bus into s390-sclp.c as a
static variable without any export since we only touch that there. We also added
an comment that by architecture definition there is only one sclp per machine, so
this should be fine.
>> --- a/hw/s390x/Makefile.objs
>> +++ b/hw/s390x/Makefile.objs
>> @@ -1,3 +1,4 @@
>> obj-y = s390-virtio-bus.o s390-virtio.o
>> +obj-y += s390-sclp.o
>>
>> obj-y := $(addprefix ../,$(obj-y))
>
> IIUC we have a dependency on the CPU inside the device code. If so,
> please move the s390-sclp.c file into hw/s390x/ and move the obj-y +=
> line below the addprefix line.
Ok.
>> diff --git a/target-s390x/cpu.c b/target-s390x/cpu.c
>> index 619b202..8900872 100644
>> --- a/target-s390x/cpu.c
>> +++ b/target-s390x/cpu.c
>> @@ -21,9 +21,26 @@
>> */
>>
>> #include "cpu.h"
>> +#include "kvm.h"
>> #include "qemu-common.h"
>> #include "qemu-timer.h"
>>
>> +/* service interrupts are floating therefore we must not pass an cpustate */
>> +void s390_sclp_extint(uint32_t parm)
>> +{
>> + S390CPU *dummy_cpu = s390_cpu_addr2state(0);
>> + CPUS390XState *env = &dummy_cpu->env;
>> +
>> + if (kvm_enabled()) {
>> +#ifdef CONFIG_KVM
>> + kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE, parm, 0, 1);
>> +#endif
>> + } else {
>> + env->psw.addr += 4;
>> + cpu_inject_ext(env, EXT_SERVICE, parm, 0);
>> + }
>> +}
>
> Not so happy about this placement, it is not called s390_cpu_, the
> prototype is in cpu.h not cpu-qom.h and it operates only indirectly on
> the CPU. Is there another place for it?
Not yet. I will try to introduce a new one, e.g. target-s390x/interrupt.c
We can then move other code there as well.
^ permalink raw reply [flat|nested] 14+ messages in thread
end of thread, other threads:[~2012-07-23 11:05 UTC | newest]
Thread overview: 14+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2012-07-13 10:51 [Qemu-devel] [PATCH 0/6v2] s390: several sclp patches Christian Borntraeger
2012-07-13 10:51 ` [Qemu-devel] [PATCH 1/6] s390: Fix error handling and condition code of service call Christian Borntraeger
2012-07-13 10:52 ` [Qemu-devel] [PATCH 2/6] s390: sclp base support Christian Borntraeger
2012-07-13 15:08 ` Blue Swirl
2012-07-13 16:44 ` Christian Borntraeger
2012-07-14 8:48 ` Blue Swirl
2012-07-16 7:04 ` Christian Borntraeger
2012-07-20 14:06 ` Andreas Färber
2012-07-23 11:05 ` Christian Borntraeger
2012-07-13 10:52 ` [Qemu-devel] [PATCH 3/6] s390: sclp event support Christian Borntraeger
2012-07-13 15:10 ` Blue Swirl
2012-07-13 10:52 ` [Qemu-devel] [PATCH 4/6] s390: sclp signal quiesce support Christian Borntraeger
2012-07-13 10:52 ` [Qemu-devel] [PATCH 5/6] s390: sclp ascii console support Christian Borntraeger
2012-07-13 10:52 ` [Qemu-devel] [PATCH 6/6] s390: make sclp ascii console the default Christian Borntraeger
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.