From patchwork Mon Mar 30 14:28:22 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michael Mueller X-Patchwork-Id: 456201 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [IPv6:2001:4830:134:3::11]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id A230414008F for ; Tue, 31 Mar 2015 01:29:45 +1100 (AEDT) Received: from localhost ([::1]:34277 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YcahD-0006Vz-RY for incoming@patchwork.ozlabs.org; Mon, 30 Mar 2015 10:29:43 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:59731) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YcagR-00059s-KW for qemu-devel@nongnu.org; Mon, 30 Mar 2015 10:29:01 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1YcagK-0006mt-OV for qemu-devel@nongnu.org; Mon, 30 Mar 2015 10:28:55 -0400 Received: from e06smtp10.uk.ibm.com ([195.75.94.106]:42402) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YcagK-0006lc-BX for qemu-devel@nongnu.org; Mon, 30 Mar 2015 10:28:48 -0400 Received: from /spool/local by e06smtp10.uk.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Mon, 30 Mar 2015 15:28:46 +0100 Received: from d06dlp01.portsmouth.uk.ibm.com (9.149.20.13) by e06smtp10.uk.ibm.com (192.168.101.140) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; Mon, 30 Mar 2015 15:28:45 +0100 Received: from b06cxnps4075.portsmouth.uk.ibm.com (d06relay12.portsmouth.uk.ibm.com [9.149.109.197]) by d06dlp01.portsmouth.uk.ibm.com (Postfix) with ESMTP id 8AE6F17D805F for ; Mon, 30 Mar 2015 15:29:14 +0100 (BST) Received: from d06av10.portsmouth.uk.ibm.com (d06av10.portsmouth.uk.ibm.com [9.149.37.251]) by b06cxnps4075.portsmouth.uk.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id t2UESiWP10813720 for ; Mon, 30 Mar 2015 14:28:44 GMT Received: from d06av10.portsmouth.uk.ibm.com (localhost [127.0.0.1]) by d06av10.portsmouth.uk.ibm.com (8.14.4/8.14.4/NCO v10.0 AVout) with ESMTP id t2UESikj015243 for ; Mon, 30 Mar 2015 08:28:44 -0600 Received: from tuxmaker.boeblingen.de.ibm.com (tuxmaker.boeblingen.de.ibm.com [9.152.85.9]) by d06av10.portsmouth.uk.ibm.com (8.14.4/8.14.4/NCO v10.0 AVin) with ESMTP id t2UESdiB014992; Mon, 30 Mar 2015 08:28:43 -0600 From: Michael Mueller To: qemu-devel@nongnu.org, kvm@vger.kernel.org, linux-s390@vger.kernel.org, linux-kernel@vger.kernel.org Date: Mon, 30 Mar 2015 16:28:22 +0200 Message-Id: <1427725708-52100-10-git-send-email-mimu@linux.vnet.ibm.com> X-Mailer: git-send-email 2.1.4 In-Reply-To: <1427725708-52100-1-git-send-email-mimu@linux.vnet.ibm.com> References: <1427725708-52100-1-git-send-email-mimu@linux.vnet.ibm.com> X-TM-AS-MML: disable X-Content-Scanned: Fidelis XPS MAILER x-cbid: 15033014-0041-0000-0000-000003C1BAEF X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x X-Received-From: 195.75.94.106 Cc: Eduardo Habkost , Gleb Natapov , Alexander Graf , Christian Borntraeger , Daniel Hansel , "Jason J. Herne" , Cornelia Huck , Paolo Bonzini , Richard Henderson , Andreas Faerber , Michael Mueller Subject: [Qemu-devel] [PATCH v4 09/15] target-s390x: Add cpu class initialization routines X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org This patch provides routines to dynamically update the previously defined S390 cpu classes in the current host context. The main function performing this process is s390_setup_cpu_classes(). It takes the current host context and a facility list mask as parameter to setup the classes accordingly. It basically performs the following sub-tasks: - Update of cpu classes with accelerator specific host and QEMU properties - Mark adequate cpu class as default cpu class to be used for cpu model 'host' - Invalidate cpu classes not supported by this hosting machine - Define machine type aliases to latest GA number of a processor model - Define aliases for common cpu model names - Set cpu model alias 'host' to default cpu class Forthermore the patch provides the following routines: - cpu_desc_avail(), s390 specific stub indicating that list_cpus() can run - s390_setup_cpu_aliases(), adds cu model aliases - s390_cpu_classes_initialized(), test if cpu classes have been initialized - s390_fac_list_mask_by_machine(), returns facility list mask by machine - s390_current_fac_list_mask(), returns facility list mask of current machine Signed-off-by: Michael Mueller --- target-s390x/cpu-models.c | 494 ++++++++++++++++++++++++++++++++++++++++++++++ target-s390x/cpu-models.h | 31 +++ target-s390x/cpu.c | 17 +- target-s390x/kvm.c | 5 +- 4 files changed, 545 insertions(+), 2 deletions(-) diff --git a/target-s390x/cpu-models.c b/target-s390x/cpu-models.c index f792066..8a877d3 100644 --- a/target-s390x/cpu-models.c +++ b/target-s390x/cpu-models.c @@ -13,6 +13,11 @@ #include "qemu-common.h" #include "cpu-models.h" #include "gen-facilities.h" +#include "qemu/error-report.h" +#ifndef CONFIG_USER_ONLY +#include "exec/cpu-common.h" +#include "hw/boards.h" +#endif #define S390_PROC_DEF(_name, _cpu_id, _desc) \ static void \ @@ -87,8 +92,41 @@ S390_PROC_DEF("2827-ga2", CPU_S390_2827_GA2, "IBM zEnterprise EC12 GA2") S390_PROC_DEF("2828-ga1", CPU_S390_2828_GA1, "IBM zEnterprise BC12 GA1") S390_PROC_DEF("2964-ga1", CPU_S390_2964_GA1, "IBM z13 GA1") +/* some types for calls to g_list_foreach() with parameters */ +typedef struct ParmBoolShortShort { + bool valid; + unsigned short type; + union { + unsigned short class; + unsigned short gen; + unsigned short ga; + }; +} ParmBoolShortShort; + +typedef struct ParmAddrAddrModeMask { + S390MachineProps *prop; + S390CPUClass *host_cc; + S390AccelMode mode; + uint64_t *mask; +} ParmAddrAddrModeMask; + static GSList *s390_cpu_aliases; +/* compare order of two cpu classes for ascending sort */ +gint s390_cpu_class_asc_order_compare(gconstpointer a, gconstpointer b) +{ + S390CPUClass *cc_a = S390_CPU_CLASS((ObjectClass *) a); + S390CPUClass *cc_b = S390_CPU_CLASS((ObjectClass *) b); + + if (cc_a->mach.order < cc_b->mach.order) { + return -1; + } + if (cc_a->mach.order > cc_b->mach.order) { + return 1; + } + return 0; +} + static gint s390_cpu_compare_class_name(gconstpointer a, gconstpointer b) { const char *aname = object_class_get_name((ObjectClass *) a); @@ -176,3 +214,459 @@ int set_s390_cpu_alias(const char *name, const char *model) return 0; } +/* return machine class for specific machine type */ +static void s390_machine_class_test_cpu_class(gpointer data, gpointer user_data) +{ + S390CPUClass *cc = S390_CPU_CLASS((ObjectClass *) data); + ParmBoolShortShort *parm = user_data; + + if (parm->valid || !cc->proc.type || parm->type != cc->proc.type) { + return; + } + + parm->class = cc->mach.class; + parm->valid = true; +} + +/* return machine class by machine type */ +static unsigned short machine_class(unsigned short type, void *user_data) +{ + GSList *list = object_class_get_list(TYPE_S390_CPU, false); + ParmBoolShortShort parm_class, *parm = user_data; + + if (parm->type != type) { + parm->class = 0; + } + if (!parm->class) { + parm_class.type = type; + parm_class.class = 0; + parm_class.valid = false; + g_slist_foreach(list, (GFunc) s390_machine_class_test_cpu_class, + &parm_class); + g_slist_free(list); + if (parm_class.valid) { + parm->class = parm_class.class; + } + } + parm->type = type; + + return parm->class; +} + +/* return CMOS generation for specific machine type */ +static void s390_machine_class_test_cpu_gen(gpointer data, gpointer user_data) +{ + S390CPUClass *cc = S390_CPU_CLASS((ObjectClass *) data); + ParmBoolShortShort *parm = user_data; + + if (parm->valid) { + return; + } + + if (parm->type == cc->proc.type) { + parm->gen = cc->proc.gen; + parm->valid = true; + } +} + +/* return CMOS generation by machine type */ +static uint16_t machine_gen(unsigned short type) +{ + GSList *list = object_class_get_list(TYPE_S390_CPU, false); + ParmBoolShortShort parm; + + parm.type = type; + parm.gen = 0; + parm.valid = false; + g_slist_foreach(list, (GFunc) s390_machine_class_test_cpu_gen, &parm); + g_slist_free(list); + + return parm.gen; +} + +/* mark cpu class, used in host cpu model case */ +static void s390_mark_host_cpu_class(gpointer data, gpointer user_data) +{ + S390CPUClass *cc = S390_CPU_CLASS((ObjectClass *) data); + ParmAddrAddrModeMask *parm = user_data; + ParmBoolShortShort parm_tc; + + if (!cc->is_active[parm->mode]) { + return; + } + + parm_tc.type = 0; + parm_tc.class = 0; + if (cc->mach.class != machine_class(cpuid_type(parm->prop->cpuid), + &parm_tc)) { + /* sort out machines that differ from host machine class */ + return; + } + if (!parm->host_cc) { + /* use first matching machine type */ + cc->is_host[parm->mode] = true; + parm->host_cc = cc; + return; + } + if (cc->proc.gen > machine_gen(cpuid_type(parm->prop->cpuid))) { + /* sort out CMOS generations later than hosts generation */ + cc->is_active[parm->mode] = false; + return; + } + if (cc->mach.order > parm->host_cc->mach.order) { + /* select later machine as host */ + parm->host_cc->is_host[parm->mode] = false; + cc->is_host[parm->mode] = true; + parm->host_cc = cc; + } +} + +/* update a specific cpu model class with host retrieved configuration */ +static void s390_update_cpu_class(gpointer data, gpointer user_data) +{ + ObjectClass *oc = data; + ParmAddrAddrModeMask *parm = user_data; + S390CPUClass *cc = S390_CPU_CLASS(oc); + uint64_t nbits = FAC_LIST_CPU_S390_SIZE_UINT1; + static uint64_t fac_list[FAC_LIST_CPU_S390_SIZE_UINT64]; + + if (!cc->proc.type) { + return; + } + + /* Set processor identifier */ + cc->proc.id = cpuid_id(parm->prop->cpuid); + + /* + * Define model specific IBC value in current host context. + * IBC was introduced with CMOS version 10 i.e. type 2097. + * For older CPUs it is assumed to be 0x000. The BC system + * has always the same IBC version as the previous EC system. + * If the host supports IBC but not the requested type, it + * will be set to the oldest supported value. + */ + if (has_ibc(parm->prop->ibc_range)) { + if (cc->proc.gen >= S390_CMOS_G10) { + cc->proc.ibc = ((cc->proc.gen - S390_CMOS_G10) << 4); + cc->proc.ibc += cc->mach.ga; + if (cc->mach.class == S390_BC) { + cc->proc.ibc++; + } + if (cc->proc.ibc < oldest_ibc(parm->prop->ibc_range)) { + cc->proc.ibc = oldest_ibc(parm->prop->ibc_range); + } + if (cc->proc.ibc > newest_ibc(parm->prop->ibc_range)) { + cc->proc.ibc = newest_ibc(parm->prop->ibc_range); + } + } else { + cc->proc.ibc = oldest_ibc(parm->prop->ibc_range); + } + } + + /* + * Processor generation and GA level specific facility properties: + * + * - cc->fac_list (RFL): + * resulting facility list to be requested for guest cpus + * - cc->proc.fac_list (PFL): + * facility list defined per processor generation and GA level + * + * Machine specific facility properties reported by the host: + * + * - parm->prop->fac_list (MFL): + * host specifc facility list, might be reduced by some facilities + * in case the host is backed by z/VM and not a LPAR + * - parm->prop->fac_list_mask (MFM): + * host specific facility list mask containing facilities + * + * QEMU defined properties: + * + * - qemu_s390_fac_list_mask (QFM): + * locally defined facilities, they are added to the set of + * facilities requested for a guest vcpu. They are visible in + * the guest and require qemu side instruction handling + * + * The calculation for the vcpu specific facility list (RFL) from the + * above defined lists/masks works as follows: + * + * RFL = PFL & (QFM | MFM) + * + * Set resulting/desired facilities of given cpu class + */ + if (parm->mask) { + bitmap_or(cc->fac_list[parm->mode], parm->mask, + parm->prop->fac_list_mask, nbits); + bitmap_and(cc->fac_list[parm->mode], cc->fac_list[parm->mode], + cc->proc.fac_list, nbits); + } else { + bitmap_and(cc->fac_list[parm->mode], parm->prop->fac_list_mask, + cc->proc.fac_list, nbits); + } + + /* + * Finally, mark the cpu class active if all resulting/desired + * facilities are offered by the host. + * (RFL & MFL) != RFL + */ + bitmap_and(fac_list, cc->fac_list[parm->mode], parm->prop->fac_list, nbits); + if (bitmap_equal(fac_list, cc->fac_list[parm->mode], nbits)) { + cc->is_active[parm->mode] = true; + } +} + +/* cpu models newer than the hosting machine are not supported */ +static void s390_disable_not_supported_cpu_class(gpointer data, + gpointer user_data) +{ + S390CPUClass *cc = S390_CPU_CLASS((ObjectClass *) data); + ParmAddrAddrModeMask *parm = user_data; + + if (!cc->is_active[parm->mode] || + cc->proc.gen < parm->host_cc->proc.gen) { + return; + } + if (cc->proc.gen == parm->host_cc->proc.gen) { + if (cc->mach.class == parm->host_cc->mach.class && + cc->mach.ga <= parm->host_cc->mach.ga) { + return; + } + if (cc->mach.class == S390_EC && + cc->mach.ga > parm->host_cc->mach.ga) { + return; + } + if (cc->mach.class == S390_BC && + cc->mach.ga < parm->host_cc->mach.ga) { + return; + } + } + cc->is_active[parm->mode] = false; +} + +static void set_s390_cpu_alias_by_type_ga(unsigned short type, + unsigned short ga) +{ + set_s390_cpu_alias(g_strdup_printf("%04x", type), + g_strdup_printf("%04x-ga%u", type, ga)); +} + +/* set cpu model type alias to newest ga release */ +static void s390_set_ga_alias(gpointer data, gpointer user_data) +{ + S390CPUClass *cc = S390_CPU_CLASS((ObjectClass *) data); + ParmBoolShortShort *parm = user_data; + + if (!cc->is_active[ACCEL_CURRENT]) { + return; + } + if (!parm->type) { + parm->type = cc->proc.type; + } + if (cc->proc.type == parm->type) { + parm->ga = cc->mach.ga; + return; + } + set_s390_cpu_alias_by_type_ga(parm->type, parm->ga); + parm->type = cc->proc.type; + parm->ga = cc->mach.ga; +} + +/* set cpu model alias host to cpu class marked is host cpu class */ +static void s390_set_host_alias(gpointer data, gpointer user_data) +{ + S390CPUClass *cc = S390_CPU_CLASS((ObjectClass *) data); + + if (cc->is_active[ACCEL_CURRENT] && cc->is_host[ACCEL_CURRENT]) { + set_s390_cpu_alias("host", g_strdup_printf("%04x-ga%u", + cc->proc.type, + cc->mach.ga)); + } +} + +/** + * s390_setup_cpu_classes: + * @mode: the accelerator mode + * @prop: the machine property structure's address + * + * This function validates the defined cpu classes against the given + * machine properties @prop. Only cpu classes that are runnable on the + * current host will be set active. In addition the corresponding + * cpuid, ibc value and the active set of facilities will be + * initialized. Depending on @mode, the function porforms operations + * on the current or the temporary accelerator properies. + * + * Since: 2.4 + */ +void s390_setup_cpu_classes(S390AccelMode mode, S390MachineProps *prop, + uint64_t *fac_list_mask) +{ + GSList *list; + ParmAddrAddrModeMask parm = { + .mode = mode, + .prop = prop, + .mask = fac_list_mask, + .host_cc = NULL, + }; + + list = object_class_get_list(TYPE_S390_CPU, false); + list = g_slist_sort(list, s390_cpu_class_asc_order_compare); + + g_slist_foreach(list, (GFunc) s390_update_cpu_class, (gpointer) &parm); + g_slist_foreach(list, (GFunc) s390_mark_host_cpu_class, (gpointer) &parm); + g_slist_foreach(list, (GFunc) s390_disable_not_supported_cpu_class, &parm); + + g_slist_free(list); +} + +/** + * s390_setup_cpu_aliases: + * + * This function addes cpu model aliases that will allow to specify common + * model names in cunjunction with the -cpu command line parameter. + * There will be aliases for cpu types, pointing to the respective newest + * ga of a cpu type, aliases like z-something which are widely known and + * a the alias host pointing to the cpu type representing the current hosting + * mahine. + * + * Since: 2.4 + */ +void s390_setup_cpu_aliases(void) +{ + GSList *list; + ParmBoolShortShort parm = { .type = 0, .ga = 0 }; + + list = object_class_get_list(TYPE_S390_CPU, false); + list = g_slist_sort(list, s390_cpu_class_asc_order_compare); + + g_slist_foreach(list, (GFunc) s390_set_ga_alias, &parm); + set_s390_cpu_alias_by_type_ga(parm.type, parm.ga); + + set_s390_cpu_alias("z900", "2064"); + set_s390_cpu_alias("z800", "2066"); + set_s390_cpu_alias("z990", "2084"); + set_s390_cpu_alias("z890", "2086"); + set_s390_cpu_alias("z9-109", "2094-ga1"); + set_s390_cpu_alias("z9", "2094"); + set_s390_cpu_alias("z9-ec", "2094"); + set_s390_cpu_alias("z9-bc", "2096"); + set_s390_cpu_alias("z10", "2097"); + set_s390_cpu_alias("z10-ec", "2097"); + set_s390_cpu_alias("z10-bc", "2098"); + set_s390_cpu_alias("z196", "2817"); + set_s390_cpu_alias("z114", "2818"); + set_s390_cpu_alias("zEC12", "2827"); + set_s390_cpu_alias("zBC12", "2828"); + set_s390_cpu_alias("z13", "2964"); + + g_slist_foreach(list, (GFunc) s390_set_host_alias, &parm); + + g_slist_free(list); +} + +/* list all supported cpu models and alias names */ +void s390_cpu_list_entry(gpointer data, gpointer user_data) +{ + ObjectClass *alias_oc, *oc = data; + CPUListState *s = user_data; + DeviceClass *dc = DEVICE_CLASS(oc); + S390CPUClass *cc = S390_CPU_CLASS(oc); + const char *typename = object_class_get_name(oc); + S390CPUAlias *alias; + GSList *item; + char *name; + + if (!kvm_enabled()) { + return; + } + if (!cc->is_active[ACCEL_CURRENT]) { + return; + } + name = g_strndup(typename, strlen(typename) - strlen("-" TYPE_S390_CPU)); + (*s->cpu_fprintf)(s->file, "s390 %-10s %s\n", name, dc->desc); + + for (item = s390_cpu_aliases; item != NULL; item = item->next) { + alias = (S390CPUAlias *) item->data; + alias_oc = s390_cpu_class_by_name(alias->model); + if (alias_oc != oc) { + continue; + } + (*s->cpu_fprintf)(s->file, "s390 %-10s (alias for %s)\n", + alias->name, name); + } + + g_free(name); +} + +/** + * s390_cpu_classes_initialized: + * + * This function indicates if the all cpu classes and their properties + * have been initialized. + * + * Returns: a boolean value. + * + * Since: 2.4 + */ +bool s390_cpu_classes_initialized(void) +{ + if (kvm_enabled()) { + return kvm_s390_cpu_classes_initialized(); + } + return false; +} + +bool cpu_desc_avail(void) +{ + return s390_cpu_classes_initialized(); +} + +/** + * s390_fac_list_mask_by_machine: + * @name: machine name + * + * This function returns the address of a facility list mask to + * be used in cunjunction with the specified machine type name + * or alias. + * + * Returns: The address of the facility list mask or %NULL in case + * @name is not a valid machine type name or alias + * + * Since: 2.4 + */ +#ifndef CONFIG_USER_ONLY +uint64_t *s390_fac_list_mask_by_machine(const char *name) +{ + uint64_t *mask = NULL; + GSList *machine, *mlist = object_class_get_list(TYPE_MACHINE, false); + MachineClass *mc; + + for (machine = mlist; machine; machine = machine->next) { + mc = machine->data; + if (!strcmp(mc->name, name) || + (mc->alias && !strcmp(mc->alias, name))) { + /* add cases as required */ + mask = qemu_s390_fac_list_mask; + break; + } + } + return mask; +} +#endif + +/** + * s390_current_fac_list_mask: + * + * This function returns the address of a facility list mask of the + * currently active machine. + * + * Returns: The address of the facility list mask. + * + * Since: 2.4 + */ +#ifndef CONFIG_USER_ONLY +uint64_t *s390_current_fac_list_mask(void) +{ + MachineClass *mc = MACHINE_GET_CLASS(MACHINE(qdev_get_machine())); + + return s390_fac_list_mask_by_machine(mc->name); +} +#endif diff --git a/target-s390x/cpu-models.h b/target-s390x/cpu-models.h index 3b75236..9562088 100644 --- a/target-s390x/cpu-models.h +++ b/target-s390x/cpu-models.h @@ -29,12 +29,32 @@ #define S390_DEF_ID 0xdecade #define S390_DEF_TYPE 0x2064 +/* first s390 CMOS generation supporting IBC */ +#define S390_CMOS_G10 0xa + #define cpu_type(x) (((x) >> 0) & 0xffff) #define cpu_order(x) (((x) >> 16) & 0xffff) #define cpu_ga(x) (((x) >> 16) & 0xf) #define cpu_class(x) (((x) >> 20) & 0x3) #define cpu_generation(x) (((x) >> 24) & 0xff) +#define cpuid_type(x) (((x) >> 16) & 0xffff) +#define cpuid_id(x) (((x) >> 32) & 0xffffff) +#define cpuid_ver(x) (((x) >> 56) & 0xff) + +#define type_cpuid(x) ((uint64_t)((x) & 0xffff) << 16) +#define id_cpuid(x) ((uint64_t)((x) & 0xffffff) << 32) +#define ver_cpuid(x) ((uint64_t)((x) & 0xff) << 56) + +#define oldest_ibc(x) (((uint32_t)(x) >> 16) & 0xfff) +#define newest_ibc(x) ((uint32_t)(x) & 0xfff) +#define has_ibc(x) (oldest_ibc(x) != 0) + +#define S390_DEF_CPUID \ + (ver_cpuid(S390_DEF_VERSION) | \ + id_cpuid(S390_DEF_ID) | \ + type_cpuid(S390_DEF_TYPE)) + ObjectClass *s390_cpu_class_by_name(const char *name); int set_s390_cpu_alias(const char *name, const char *model); @@ -80,6 +100,17 @@ static inline bool kvm_s390_cpu_classes_initialized(void) } #endif +void s390_setup_cpu_classes(S390AccelMode mode, S390MachineProps *prop, + uint64_t *fac_list_mask); +void s390_setup_cpu_aliases(void); +gint s390_cpu_class_asc_order_compare(gconstpointer a, gconstpointer b); +void s390_cpu_list_entry(gpointer data, gpointer user_data); +bool s390_cpu_classes_initialized(void); +uint64_t *s390_fac_list_mask_by_machine(const char *name); +uint64_t *s390_current_fac_list_mask(void); + +extern uint64_t qemu_s390_fac_list_mask[]; + /* * bits 0-7 : CMOS generation * bits 8-9 : reserved diff --git a/target-s390x/cpu.c b/target-s390x/cpu.c index 2b78e6a..c33f05e 100644 --- a/target-s390x/cpu.c +++ b/target-s390x/cpu.c @@ -41,7 +41,22 @@ void s390_cpu_list(FILE *f, fprintf_function cpu_fprintf) { #ifdef CONFIG_KVM - (*cpu_fprintf)(f, "s390 %16s\n", "host"); + CPUListState s = { + .file = f, + .cpu_fprintf = cpu_fprintf, + }; + GSList *list; + + if (kvm_enabled() && s390_cpu_classes_initialized()) { + list = object_class_get_list(TYPE_S390_CPU, false); + list = g_slist_sort(list, s390_cpu_class_asc_order_compare); + g_slist_foreach(list, s390_cpu_list_entry, &s); + g_slist_free(list); + } else { +#endif + (*cpu_fprintf)(f, "s390 host\n"); +#ifdef CONFIG_KVM + } #endif } diff --git a/target-s390x/kvm.c b/target-s390x/kvm.c index bde4aaa..9b2cfeb 100644 --- a/target-s390x/kvm.c +++ b/target-s390x/kvm.c @@ -293,7 +293,10 @@ static void kvm_setup_cpu_classes(KVMState *s) S390MachineProps mach; if (!kvm_s390_get_machine_props(s, &mach)) { - cpu_classes_initialized = false; + s390_setup_cpu_classes(ACCEL_CURRENT, &mach, + s390_current_fac_list_mask()); + s390_setup_cpu_aliases(); + cpu_classes_initialized = true; } }