openkylin
/
qemu
mirror of https://gitee.com/openkylin/qemu.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

CPU hotplug via cpu-add for s390x, cleanup of the s390x machine 

compat code and a bugfix in the s390-ccw bios.
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1.4.11 (GNU/Linux)
 
 iQIcBAABAgAGBQJW4pRSAAoJEN7Pa5PG8C+vFeYP/2dii92VFYHAWHkj0DSLfQED
 Zl0isJdxseeboONCYpgY7JelwPlsVr+p2WRa8b+DnIdPOMnq++eND01n49iF30yj
 4dEAOES63trY3cjFX05wBePo7VbREjQq4dHIOu/QMjvhKCupOTrksB76qaVPng5L
 Lt3PgruvVsR+68A+gdvVhMBAg8ZWIIPw/tGNTNJvLeqP+SnF7eQ4x6Rkmc3FLohJ
 8AmI15+pMJ07HIESVRaKn4xGvOPs+P7HsBAgUaH+SM8ihyacQintXQ4kh/HFbPwe
 ffr55WlOlkU124jPXVA3a0L5oQ8RHytPzA7SQis+HFWOfvRM/r0kDtKtKNCZ53jH
 UXeX+CcbtB0T3zuNCVB+oAE+M3hJXhmfdPSLESl+gqxBdFTHrx3QJcxcpIRRGi32
 diwoSr+m+KL0Dmv0DUDwzs7bbkhsjMTaL64GzDIPA9OrAZARxc28icD5IxtmVHbB
 UiC/2V/DAY7xi9mHYoP5vyHUQTbsKtWCN3s/DbB3YzlQAMZGkXQGL2xGaxAmIkaQ
 axpHmXwBnY1RNd2zwk9CmKcjsVuXpPJPOvmfMgPVwQBEnKM+xnfflrwjpJ3wzZHm
 nFQdGOJkrTr/MZTjELlKmuCpCzcF1CS99muW3ZCq97cTlTVlx0sqjVsYkwCLqvgW
 ONkC3Xg9MetbIXmfbZcu
 =JnlS
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20160311' into staging

CPU hotplug via cpu-add for s390x, cleanup of the s390x machine
compat code and a bugfix in the s390-ccw bios.

# gpg: Signature made Fri 11 Mar 2016 09:48:02 GMT using RSA key ID C6F02FAF
# gpg: Good signature from "Cornelia Huck <huckc@linux.vnet.ibm.com>"
# gpg:                 aka "Cornelia Huck <cornelia.huck@de.ibm.com>"

* remotes/cohuck/tags/s390x-20160311:
  s390x/cpu: use g_new0
  s390x: Introduce S390MachineClass
  s390x: Introduce machine definition macros
  pc-bios/s390-ccw: fix old bug in ptr increment
  s390x/cpu: Allow hotplug of CPUs
  s390x/cpu: Add error handling to cpu creation
  s390x/cpu: Add CPU property links
  s390x/cpu: Tolerate max_cpus
  s390x/cpu: Get rid of side effects when creating a vcpu
  s390x/cpu: Set initial CPU state in common routine
  s390x/cpu: Cleanup init in preparation for hotplug

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2016-03-14 11:13:11 +00:00
parent a648c13738 75cfb3bb41
commit d1ab9681ac
9 changed files with 289 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
hw/s390x/s390-virtio-ccw.c
View File

@ -22,20 +22,7 @@
#include "s390-pci-bus.h"
#include "hw/s390x/storage-keys.h"
#include "hw/compat.h"
#define TYPE_S390_CCW_MACHINE "s390-ccw-machine"
#define S390_CCW_MACHINE(obj) \
OBJECT_CHECK(S390CcwMachineState, (obj), TYPE_S390_CCW_MACHINE)
typedef struct S390CcwMachineState {
/*< private >*/
MachineState parent_obj;
/*< public >*/
bool aes_key_wrap;
bool dea_key_wrap;
} S390CcwMachineState;
#include "hw/s390x/s390-virtio-ccw.h"
static const char *const reset_dev_types[] = {
"virtual-css-bridge",
@ -136,7 +123,7 @@ static void ccw_init(MachineState *machine)
virtio_ccw_register_hcalls();
/* init CPUs */
s390_init_cpus(machine->cpu_model);
s390_init_cpus(machine);
if (kvm_enabled()) {
kvm_s390_enable_css_support(s390_cpu_addr2state(0));
@ -156,13 +143,54 @@ static void ccw_init(MachineState *machine)
gtod_save, gtod_load, kvm_state);
}
static void s390_cpu_plug(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
gchar *name;
S390CPU *cpu = S390_CPU(dev);
CPUState *cs = CPU(dev);
name = g_strdup_printf("cpu[%i]", cpu->env.cpu_num);
object_property_set_link(OBJECT(hotplug_dev), OBJECT(cs), name,
errp);
g_free(name);
}
static void s390_machine_device_plug(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
s390_cpu_plug(hotplug_dev, dev, errp);
}
}
static HotplugHandler *s390_get_hotplug_handler(MachineState *machine,
DeviceState *dev)
{
if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
return HOTPLUG_HANDLER(machine);
}
return NULL;
}
static void s390_hot_add_cpu(const int64_t id, Error **errp)
{
MachineState *machine = MACHINE(qdev_get_machine());
Error *err = NULL;
s390x_new_cpu(machine->cpu_model, id, &err);
error_propagate(errp, err);
}
static void ccw_machine_class_init(ObjectClass *oc, void *data)
{
MachineClass *mc = MACHINE_CLASS(oc);
NMIClass *nc = NMI_CLASS(oc);
HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
mc->init = ccw_init;
mc->reset = s390_machine_reset;
mc->hot_add_cpu = s390_hot_add_cpu;
mc->block_default_type = IF_VIRTIO;
mc->no_cdrom = 1;
mc->no_floppy = 1;
@ -171,6 +199,8 @@ static void ccw_machine_class_init(ObjectClass *oc, void *data)
mc->no_sdcard = 1;
mc->use_sclp = 1;
mc->max_cpus = 255;
mc->get_hotplug_handler = s390_get_hotplug_handler;
hc->plug = s390_machine_device_plug;
nc->nmi_monitor_handler = s390_nmi;
}
@ -232,10 +262,40 @@ static const TypeInfo ccw_machine_info = {
.class_init = ccw_machine_class_init,
.interfaces = (InterfaceInfo[]) {
{ TYPE_NMI },
{ TYPE_HOTPLUG_HANDLER},
{ }
},
};
#define DEFINE_CCW_MACHINE(suffix, verstr, latest) \
static void ccw_machine_##suffix##_class_init(ObjectClass *oc, \
void *data) \
{ \
MachineClass *mc = MACHINE_CLASS(oc); \
ccw_machine_##suffix##_class_options(mc); \
mc->desc = "VirtIO-ccw based S390 machine v" verstr; \
if (latest) { \
mc->alias = "s390-ccw-virtio"; \
mc->is_default = 1; \
} \
} \
static void ccw_machine_##suffix##_instance_init(Object *obj) \
{ \
MachineState *machine = MACHINE(obj); \
ccw_machine_##suffix##_instance_options(machine); \
} \
static const TypeInfo ccw_machine_##suffix##_info = { \
.name = MACHINE_TYPE_NAME("s390-ccw-virtio-" verstr), \
.parent = TYPE_S390_CCW_MACHINE, \
.class_init = ccw_machine_##suffix##_class_init, \
.instance_init = ccw_machine_##suffix##_instance_init, \
}; \
static void ccw_machine_register_##suffix(void) \
{ \
type_register_static(&ccw_machine_##suffix##_info); \
} \
machine_init(ccw_machine_register_##suffix)
#define CCW_COMPAT_2_5 \
HW_COMPAT_2_5
@ -280,63 +340,39 @@ static const TypeInfo ccw_machine_info = {
.value = "0",\
},
static void ccw_machine_2_4_class_init(ObjectClass *oc, void *data)
static void ccw_machine_2_6_instance_options(MachineState *machine)
{
MachineClass *mc = MACHINE_CLASS(oc);
static GlobalProperty compat_props[] = {
CCW_COMPAT_2_4
{ /* end of list */ }
};
mc->desc = "VirtIO-ccw based S390 machine v2.4";
mc->compat_props = compat_props;
}
static const TypeInfo ccw_machine_2_4_info = {
.name = MACHINE_TYPE_NAME("s390-ccw-virtio-2.4"),
.parent = TYPE_S390_CCW_MACHINE,
.class_init = ccw_machine_2_4_class_init,
};
static void ccw_machine_2_5_class_init(ObjectClass *oc, void *data)
static void ccw_machine_2_6_class_options(MachineClass *mc)
{
MachineClass *mc = MACHINE_CLASS(oc);
static GlobalProperty compat_props[] = {
CCW_COMPAT_2_5
{ /* end of list */ }
};
}
DEFINE_CCW_MACHINE(2_6, "2.6", true);
mc->desc = "VirtIO-ccw based S390 machine v2.5";
mc->compat_props = compat_props;
static void ccw_machine_2_5_instance_options(MachineState *machine)
{
}
static const TypeInfo ccw_machine_2_5_info = {
.name = MACHINE_TYPE_NAME("s390-ccw-virtio-2.5"),
.parent = TYPE_S390_CCW_MACHINE,
.class_init = ccw_machine_2_5_class_init,
};
static void ccw_machine_2_6_class_init(ObjectClass *oc, void *data)
static void ccw_machine_2_5_class_options(MachineClass *mc)
{
MachineClass *mc = MACHINE_CLASS(oc);
SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_5);
}
DEFINE_CCW_MACHINE(2_5, "2.5", false);
mc->alias = "s390-ccw-virtio";
mc->desc = "VirtIO-ccw based S390 machine v2.6";
mc->is_default = 1;
static void ccw_machine_2_4_instance_options(MachineState *machine)
{
ccw_machine_2_5_instance_options(machine);
}
static const TypeInfo ccw_machine_2_6_info = {
.name = MACHINE_TYPE_NAME("s390-ccw-virtio-2.6"),
.parent = TYPE_S390_CCW_MACHINE,
.class_init = ccw_machine_2_6_class_init,
};
static void ccw_machine_2_4_class_options(MachineClass *mc)
{
SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_4);
}
DEFINE_CCW_MACHINE(2_4, "2.4", false);
static void ccw_machine_register_types(void)
{
type_register_static(&ccw_machine_info);
type_register_static(&ccw_machine_2_4_info);
type_register_static(&ccw_machine_2_5_info);
type_register_static(&ccw_machine_2_6_info);
}
type_init(ccw_machine_register_types)

36
hw/s390x/s390-virtio.c
View File

@ -58,15 +58,16 @@
#define S390_TOD_CLOCK_VALUE_MISSING 0x00
#define S390_TOD_CLOCK_VALUE_PRESENT 0x01
static S390CPU **ipi_states;
static S390CPU **cpu_states;
S390CPU *s390_cpu_addr2state(uint16_t cpu_addr)
{
if (cpu_addr >= smp_cpus) {
if (cpu_addr >= max_cpus) {
return NULL;
}
return ipi_states[cpu_addr];
/* Fast lookup via CPU ID */
return cpu_states[cpu_addr];
}
void s390_init_ipl_dev(const char *kernel_filename,
@ -93,26 +94,29 @@ void s390_init_ipl_dev(const char *kernel_filename,
qdev_init_nofail(dev);
}
void s390_init_cpus(const char *cpu_model)
void s390_init_cpus(MachineState *machine)
{
int i;
gchar *name;
if (cpu_model == NULL) {
cpu_model = "host";
if (machine->cpu_model == NULL) {
machine->cpu_model = "host";
}
ipi_states = g_malloc(sizeof(S390CPU *) * smp_cpus);
cpu_states = g_new0(S390CPU *, max_cpus);
for (i = 0; i < max_cpus; i++) {
name = g_strdup_printf("cpu[%i]", i);
object_property_add_link(OBJECT(machine), name, TYPE_S390_CPU,
(Object **) &cpu_states[i],
object_property_allow_set_link,
OBJ_PROP_LINK_UNREF_ON_RELEASE,
&error_abort);
g_free(name);
}
for (i = 0; i < smp_cpus; i++) {
S390CPU *cpu;
CPUState *cs;
cpu = cpu_s390x_init(cpu_model);
cs = CPU(cpu);
ipi_states[i] = cpu;
cs->halted = 1;
cs->exception_index = EXCP_HLT;
s390x_new_cpu(machine->cpu_model, i, &error_fatal);
}
}

2
hw/s390x/s390-virtio.h
View File

@ -19,7 +19,7 @@
typedef int (*s390_virtio_fn)(const uint64_t *args);
void s390_register_virtio_hypercall(uint64_t code, s390_virtio_fn fn);
void s390_init_cpus(const char *cpu_model);
void s390_init_cpus(MachineState *machine);
void s390_init_ipl_dev(const char *kernel_filename,
const char *kernel_cmdline,
const char *initrd_filename,

40
include/hw/s390x/s390-virtio-ccw.h Normal file
View File

@ -0,0 +1,40 @@
/*
* virtio ccw machine definitions
*
* Copyright 2012, 2016 IBM Corp.
* Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or (at
* your option) any later version. See the COPYING file in the top-level
* directory.
*/
#ifndef HW_S390X_S390_VIRTIO_CCW_H
#define HW_S390X_S390_VIRTIO_CCW_H
#include "hw/boards.h"
#define TYPE_S390_CCW_MACHINE "s390-ccw-machine"
#define S390_CCW_MACHINE(obj) \
OBJECT_CHECK(S390CcwMachineState, (obj), TYPE_S390_CCW_MACHINE)
#define S390_MACHINE_CLASS(klass) \
OBJECT_CLASS_CHECK(S390CcwMachineClass, (klass), TYPE_S390_CCW_MACHINE)
typedef struct S390CcwMachineState {
/*< private >*/
MachineState parent_obj;
/*< public >*/
bool aes_key_wrap;
bool dea_key_wrap;
} S390CcwMachineState;
typedef struct S390CcwMachineClass {
/*< private >*/
MachineClass parent_class;
/*< public >*/
} S390CcwMachineClass;
#endif

2
pc-bios/s390-ccw/bootmap.c
View File

@ -424,7 +424,7 @@ static void ipl_scsi(void)
IPL_assert(magic_match(sec, ZIPL_MAGIC), "No zIPL magic");
ns_end = sec + virtio_get_block_size();
for (ns = (sec + pte_len); (ns + pte_len) < ns_end; ns++) {
for (ns = (sec + pte_len); (ns + pte_len) < ns_end; ns += pte_len) {
prog_table_entry = (ScsiBlockPtr *)ns;
if (!prog_table_entry->blockno) {
break;

3
target-s390x/cpu-qom.h
View File

@ -47,6 +47,8 @@ typedef struct S390CPUClass {
CPUClass parent_class;
/*< public >*/
int64_t next_cpu_id;
DeviceRealize parent_realize;
void (*parent_reset)(CPUState *cpu);
void (*load_normal)(CPUState *cpu);
@ -66,6 +68,7 @@ typedef struct S390CPU {
/*< public >*/
CPUS390XState env;
int64_t id;
/* needed for live migration */
void *irqstate;
uint32_t irqstate_saved_size;

96
target-s390x/cpu.c
View File

@ -30,8 +30,11 @@
#include "qemu/error-report.h"
#include "hw/hw.h"
#include "trace.h"
#include "qapi/visitor.h"
#ifndef CONFIG_USER_ONLY
#include "sysemu/arch_init.h"
#include "sysemu/sysemu.h"
#include "hw/s390x/sclp.h"
#endif
#define CR0_RESET 0xE0UL
@ -195,7 +198,39 @@ static void s390_cpu_realizefn(DeviceState *dev, Error **errp)
{
CPUState *cs = CPU(dev);
S390CPUClass *scc = S390_CPU_GET_CLASS(dev);
S390CPU *cpu = S390_CPU(dev);
CPUS390XState *env = &cpu->env;
Error *err = NULL;
#if !defined(CONFIG_USER_ONLY)
if (cpu->id >= max_cpus) {
error_setg(&err, "Unable to add CPU: %" PRIi64
", max allowed: %d", cpu->id, max_cpus - 1);
goto out;
}
#endif
if (cpu_exists(cpu->id)) {
error_setg(&err, "Unable to add CPU: %" PRIi64
", it already exists", cpu->id);
goto out;
}
if (cpu->id != scc->next_cpu_id) {
error_setg(&err, "Unable to add CPU: %" PRIi64
", The next available id is %" PRIi64, cpu->id,
scc->next_cpu_id);
goto out;
}
cpu_exec_init(cs, &err);
if (err != NULL) {
goto out;
}
scc->next_cpu_id++;
#if !defined(CONFIG_USER_ONLY)
qemu_register_reset(s390_cpu_machine_reset_cb, cpu);
#endif
env->cpu_num = cpu->id;
s390_cpu_gdb_init(cs);
qemu_init_vcpu(cs);
#if !defined(CONFIG_USER_ONLY)
@ -204,7 +239,55 @@ static void s390_cpu_realizefn(DeviceState *dev, Error **errp)
cpu_reset(cs);
#endif
scc->parent_realize(dev, errp);
scc->parent_realize(dev, &err);
#if !defined(CONFIG_USER_ONLY)
if (dev->hotplugged) {
raise_irq_cpu_hotplug();
}
#endif
out:
error_propagate(errp, err);
}
static void s390x_cpu_get_id(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
S390CPU *cpu = S390_CPU(obj);
int64_t value = cpu->id;
visit_type_int(v, name, &value, errp);
}
static void s390x_cpu_set_id(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
S390CPU *cpu = S390_CPU(obj);
DeviceState *dev = DEVICE(obj);
const int64_t min = 0;
const int64_t max = UINT32_MAX;
Error *err = NULL;
int64_t value;
if (dev->realized) {
error_setg(errp, "Attempt to set property '%s' on '%s' after "
"it was realized", name, object_get_typename(obj));
return;
}
visit_type_int(v, name, &value, &err);
if (err) {
error_propagate(errp, err);
return;
}
if (value < min || value > max) {
error_setg(errp, "Property %s.%s doesn't take value %" PRId64
" (minimum: %" PRId64 ", maximum: %" PRId64 ")" ,
object_get_typename(obj), name, value, min, max);
return;
}
cpu->id = value;
}
static void s390_cpu_initfn(Object *obj)
@ -213,15 +296,16 @@ static void s390_cpu_initfn(Object *obj)
S390CPU *cpu = S390_CPU(obj);
CPUS390XState *env = &cpu->env;
static bool inited;
static int cpu_num = 0;
#if !defined(CONFIG_USER_ONLY)
struct tm tm;
#endif
cs->env_ptr = env;
cpu_exec_init(cs, &error_abort);
cs->halted = 1;
cs->exception_index = EXCP_HLT;
object_property_add(OBJECT(cpu), "id", "int64_t", s390x_cpu_get_id,
s390x_cpu_set_id, NULL, NULL, NULL);
#if !defined(CONFIG_USER_ONLY)
qemu_register_reset(s390_cpu_machine_reset_cb, cpu);
qemu_get_timedate(&tm, 0);
env->tod_offset = TOD_UNIX_EPOCH +
(time2tod(mktimegm(&tm)) * 1000000000ULL);
@ -230,7 +314,6 @@ static void s390_cpu_initfn(Object *obj)
env->cpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, s390x_cpu_timer, cpu);
s390_cpu_set_state(CPU_STATE_STOPPED, cpu);
#endif
env->cpu_num = cpu_num++;
if (tcg_enabled() && !inited) {
inited = true;
@ -337,6 +420,7 @@ static void s390_cpu_class_init(ObjectClass *oc, void *data)
CPUClass *cc = CPU_CLASS(scc);
DeviceClass *dc = DEVICE_CLASS(oc);
scc->next_cpu_id = 0;
scc->parent_realize = dc->realize;
dc->realize = s390_cpu_realizefn;
@ -369,7 +453,7 @@ static void s390_cpu_class_init(ObjectClass *oc, void *data)
cc->gdb_arch_name = s390_gdb_arch_name;
/*
* Reason: s390_cpu_initfn() calls cpu_exec_init(), which saves
* Reason: s390_cpu_realizefn() calls cpu_exec_init(), which saves
* the object in cpus -> dangling pointer after final
* object_unref().
*/

2
target-s390x/cpu.h
View File

@ -413,6 +413,8 @@ void trigger_pgm_exception(CPUS390XState *env, uint32_t code, uint32_t ilen);
#endif
S390CPU *cpu_s390x_init(const char *cpu_model);
S390CPU *s390x_new_cpu(const char *cpu_model, int64_t id, Error **errp);
S390CPU *cpu_s390x_create(const char *cpu_model, Error **errp);
void s390x_translate_init(void);
int cpu_s390x_exec(CPUState *cpu);

41
target-s390x/helper.c
View File

@ -65,14 +65,51 @@ void s390x_cpu_timer(void *opaque)
}
#endif
S390CPU *cpu_s390x_init(const char *cpu_model)
S390CPU *cpu_s390x_create(const char *cpu_model, Error **errp)
{
S390CPU *cpu;
cpu = S390_CPU(object_new(TYPE_S390_CPU));
object_property_set_bool(OBJECT(cpu), true, "realized", NULL);
return cpu;
}
S390CPU *s390x_new_cpu(const char *cpu_model, int64_t id, Error **errp)
{
S390CPU *cpu;
Error *err = NULL;
cpu = cpu_s390x_create(cpu_model, &err);
if (err != NULL) {
goto out;
}
object_property_set_int(OBJECT(cpu), id, "id", &err);
if (err != NULL) {
goto out;
}
object_property_set_bool(OBJECT(cpu), true, "realized", &err);
out:
if (err) {
error_propagate(errp, err);
object_unref(OBJECT(cpu));
cpu = NULL;
}
return cpu;
}
S390CPU *cpu_s390x_init(const char *cpu_model)
{
Error *err = NULL;
S390CPU *cpu;
/* Use to track CPU ID for linux-user only */
static int64_t next_cpu_id;
cpu = s390x_new_cpu(cpu_model, next_cpu_id++, &err);
if (err) {
error_report_err(err);
}
return cpu;
}