Instead of requiring cpu.c to check if TCG was already initialized, simply let the function be called multiple times. Suggested-by: Igor Mammedov <imammedo(a)redhat.com&gt; Signed-off-by: Eduardo Habkost <ehabkost(a)redhat.com&gt; --- target-i386/cpu.c | 4 +--- target-i386/translate.c | 6 ++++++ 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/target-i386/cpu.c b/target-i386/cpu.c index 4856cd4..a689fec 100644 --- a/target-i386/cpu.c +++ b/target-i386/cpu.c @@ -3087,7 +3087,6 @@ static void x86_cpu_initfn(Object *obj) X86CPUClass *xcc = X86_CPU_GET_CLASS(obj); CPUX86State *env = &cpu->env; FeatureWord w; - static int inited; cs->env_ptr = env; cpu_exec_init(cs, &error_abort); @@ -3138,8 +3137,7 @@ static void x86_cpu_initfn(Object *obj) x86_cpu_load_def(cpu, xcc->cpu_def, &error_abort); /* init various static tables used in TCG mode */ - if (tcg_enabled() && !inited) { - inited = 1; + if (tcg_enabled()) { tcg_x86_init(); } } diff --git a/target-i386/translate.c b/target-i386/translate.c index 1a1214d..92570b4 100644 --- a/target-i386/translate.c +++ b/target-i386/translate.c @@ -8133,6 +8133,12 @@ void tcg_x86_init(void) "bnd0_ub", "bnd1_ub", "bnd2_ub", "bnd3_ub" }; int i; + static bool initialized = false; + + if (initialized) { + return; + } + initialized = true; cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env"); cpu_cc_op = tcg_global_mem_new_i32(cpu_env, -- 2.5.5

QOM instance_init functions are not supposed to have any side-effects, as new objects may be created at any moment for querying property information (see qmp_device_list_properties()). Move TCG initialization to realize time so it won't be called when just doing object_new() on a X86CPU subclass. Signed-off-by: Eduardo Habkost <ehabkost(a)redhat.com&gt; --- Changes v1 -> v2: * Now the inited/tcg_initialized variable doesn't exist anymore * Move tcg_x86_init() call after basic parameter validation inside realizefn --- target-i386/cpu.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/target-i386/cpu.c b/target-i386/cpu.c index a689fec..bde649a 100644 --- a/target-i386/cpu.c +++ b/target-i386/cpu.c @@ -2901,6 +2901,10 @@ static void x86_cpu_realizefn(DeviceState *dev, Error **errp) } + if (tcg_enabled()) { + tcg_x86_init(); + } + #ifndef CONFIG_USER_ONLY qemu_register_reset(x86_cpu_machine_reset_cb, cpu); @@ -3135,11 +3139,6 @@ static void x86_cpu_initfn(Object *obj) } x86_cpu_load_def(cpu, xcc->cpu_def, &error_abort); - - /* init various static tables used in TCG mode */ - if (tcg_enabled()) { - tcg_x86_init(); - } } static int64_t x86_cpu_get_arch_id(CPUState *cs) -- 2.5.5

QOM instance_init functions are not supposed to have any side-effects, as new objects may be created at any moment for querying property information (see qmp_device_list_properties()). Calling cpu_exec_init() also affects QEMU's ability to handle errors during CPU creation, as some actions done by cpu_exec_init() can't be reverted. Move cpu_exec_init() call to realize so a simple object_new() won't trigger it, and so that it is called after some basic validation of CPU parameters. Signed-off-by: Eduardo Habkost <ehabkost(a)redhat.com&gt; --- Changes v1 -> v2: * Call cpu_exec_init() after basic parameter validation --- target-i386/cpu.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/target-i386/cpu.c b/target-i386/cpu.c index bde649a..26a5a6b 100644 --- a/target-i386/cpu.c +++ b/target-i386/cpu.c @@ -2901,6 +2901,8 @@ static void x86_cpu_realizefn(DeviceState *dev, Error **errp) } + cpu_exec_init(cs, &error_abort); + if (tcg_enabled()) { tcg_x86_init(); } @@ -3093,7 +3095,6 @@ static void x86_cpu_initfn(Object *obj) FeatureWord w; cs->env_ptr = env; - cpu_exec_init(cs, &error_abort); object_property_add(obj, "family", "int", x86_cpuid_version_get_family, -- 2.5.5

Instead of using the builtin_x86_defs array, use the QOM subclass list to list CPU models on "-cpu ?" and "query-cpu-definitions". Signed-off-by: Andreas Färber <afaerber(a)suse.de&gt; [ehabkost: copied code from a patch by Andreas: "target-i386: QOM'ify CPU", from March 2012] Signed-off-by: Eduardo Habkost <ehabkost(a)redhat.com&gt; --- target-i386/cpu-qom.h | 4 ++ target-i386/cpu.c | 111 +++++++++++++++++++++++++++++++++++++------------- 2 files changed, 86 insertions(+), 29 deletions(-) diff --git a/target-i386/cpu-qom.h b/target-i386/cpu-qom.h index cb75017..c23b634 100644 --- a/target-i386/cpu-qom.h +++ b/target-i386/cpu-qom.h @@ -64,6 +64,10 @@ typedef struct X86CPUClass { bool kvm_required; + /* Optional description of CPU model. + * If unavailable, cpu_def->model_id is used */ + const char *model_description; + DeviceRealize parent_realize; void (*parent_reset)(CPUState *cpu); } X86CPUClass; diff --git a/target-i386/cpu.c b/target-i386/cpu.c index 26a5a6b..037b602 100644 --- a/target-i386/cpu.c +++ b/target-i386/cpu.c @@ -676,6 +676,14 @@ static ObjectClass *x86_cpu_class_by_name(const char *cpu_model) return oc; } +static char *x86_cpu_class_get_model_name(X86CPUClass *cc) +{ + const char *class_name = object_class_get_name(OBJECT_CLASS(cc)); + assert(g_str_has_suffix(class_name, X86_CPU_TYPE_SUFFIX)); + return g_strndup(class_name, + strlen(class_name) - strlen(X86_CPU_TYPE_SUFFIX)); +} + struct X86CPUDefinition { const char *name; uint32_t level; @@ -1484,6 +1492,9 @@ static void host_x86_cpu_class_init(ObjectClass *oc, void *data) cpu_x86_fill_model_id(host_cpudef.model_id); xcc->cpu_def = &host_cpudef; + xcc->model_description = + "KVM processor with all supported host features " + "(only available in KVM mode)"; /* level, xlevel, xlevel2, and the feature words are initialized on * instance_init, because they require KVM to be initialized. @@ -2009,23 +2020,62 @@ static void listflags(FILE *f, fprintf_function print, const char **featureset) } } -/* generate CPU information. */ +/* Sort alphabetically by type name, listing kvm_required models last. */ +static gint x86_cpu_list_compare(gconstpointer a, gconstpointer b) +{ + ObjectClass *class_a = (ObjectClass *)a; + ObjectClass *class_b = (ObjectClass *)b; + X86CPUClass *cc_a = X86_CPU_CLASS(class_a); + X86CPUClass *cc_b = X86_CPU_CLASS(class_b); + const char *name_a, *name_b; + + if (cc_a->kvm_required != cc_b->kvm_required) { + /* kvm_required items go last */ + return cc_a->kvm_required ? 1 : -1; + } else { + name_a = object_class_get_name(class_a); + name_b = object_class_get_name(class_b); + return strcmp(name_a, name_b); + } +} + +static GSList *get_sorted_cpu_model_list(void) +{ + GSList *list = object_class_get_list(TYPE_X86_CPU, false); + list = g_slist_sort(list, x86_cpu_list_compare); + return list; +} + +static void x86_cpu_list_entry(gpointer data, gpointer user_data) +{ + ObjectClass *oc = data; + X86CPUClass *cc = X86_CPU_CLASS(oc); + CPUListState *s = user_data; + char *name = x86_cpu_class_get_model_name(cc); + const char *desc = cc->model_description; + if (!desc) { + desc = cc->cpu_def->model_id; + } + + (*s->cpu_fprintf)(s->file, "x86 %16s %-48s\n", + name, desc); + g_free(name); +} + +/* list available CPU models and flags */ void x86_cpu_list(FILE *f, fprintf_function cpu_fprintf) { - X86CPUDefinition *def; - char buf[256]; int i; + CPUListState s = { + .file = f, + .cpu_fprintf = cpu_fprintf, + }; + GSList *list; - for (i = 0; i < ARRAY_SIZE(builtin_x86_defs); i++) { - def = &builtin_x86_defs[i]; - snprintf(buf, sizeof(buf), "%s", def->name); - (*cpu_fprintf)(f, "x86 %16s %-48s\n", buf, def->model_id); - } -#ifdef CONFIG_KVM - (*cpu_fprintf)(f, "x86 %16s %-48s\n", "host", - "KVM processor with all supported host features " - "(only available in KVM mode)"); -#endif + (*cpu_fprintf)(f, "Available CPUs:\n"); + list = get_sorted_cpu_model_list(); + g_slist_foreach(list, x86_cpu_list_entry, &s); + g_slist_free(list); (*cpu_fprintf)(f, "\nRecognized CPUID flags:\n"); for (i = 0; i < ARRAY_SIZE(feature_word_info); i++) { @@ -2037,26 +2087,29 @@ void x86_cpu_list(FILE *f, fprintf_function cpu_fprintf) } } -CpuDefinitionInfoList *arch_query_cpu_definitions(Error **errp) +static void x86_cpu_definition_entry(gpointer data, gpointer user_data) { - CpuDefinitionInfoList *cpu_list = NULL; - X86CPUDefinition *def; - int i; - - for (i = 0; i < ARRAY_SIZE(builtin_x86_defs); i++) { - CpuDefinitionInfoList *entry; - CpuDefinitionInfo *info; + ObjectClass *oc = data; + X86CPUClass *cc = X86_CPU_CLASS(oc); + CpuDefinitionInfoList **cpu_list = user_data; + CpuDefinitionInfoList *entry; + CpuDefinitionInfo *info; - def = &builtin_x86_defs[i]; - info = g_malloc0(sizeof(*info)); - info->name = g_strdup(def->name); + info = g_malloc0(sizeof(*info)); + info->name = x86_cpu_class_get_model_name(cc); - entry = g_malloc0(sizeof(*entry)); - entry->value = info; - entry->next = cpu_list; - cpu_list = entry; - } + entry = g_malloc0(sizeof(*entry)); + entry->value = info; + entry->next = *cpu_list; + *cpu_list = entry; +} +CpuDefinitionInfoList *arch_query_cpu_definitions(Error **errp) +{ + CpuDefinitionInfoList *cpu_list = NULL; + GSList *list = get_sorted_cpu_model_list(); + g_slist_foreach(list, x86_cpu_definition_entry, &cpu_list); + g_slist_free(list); return cpu_list; } -- 2.5.5

Just move code to another place so the it can be reused by the query-cpu-definitions code. Signed-off-by: Eduardo Habkost <ehabkost(a)redhat.com&gt; --- target-i386/cpu.c | 68 +++++++++++++++++++++++++++---------------------------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/target-i386/cpu.c b/target-i386/cpu.c index 465c125..309ef55 100644 --- a/target-i386/cpu.c +++ b/target-i386/cpu.c @@ -2005,6 +2005,40 @@ static void x86_cpu_parse_featurestr(CPUState *cs, char *features, } } +/* + * Filters CPU feature words based on host availability of each feature. + * + * Returns: 0 if all flags are supported by the host, non-zero otherwise. + */ +static int x86_cpu_filter_features(X86CPU *cpu) +{ + CPUX86State *env = &cpu->env; + FeatureWord w; + int rv = 0; + + for (w = 0; w < FEATURE_WORDS; w++) { + uint32_t host_feat = + x86_cpu_get_supported_feature_word(w, cpu->migratable); + uint32_t requested_features = env->features[w]; + env->features[w] &= host_feat; + cpu->filtered_features[w] = requested_features & ~env->features[w]; + if (cpu->filtered_features[w]) { + rv = 1; + } + } + + return rv; +} + +static void x86_cpu_report_filtered_features(X86CPU *cpu) +{ + FeatureWord w; + + for (w = 0; w < FEATURE_WORDS; w++) { + report_unavailable_features(w, cpu->filtered_features[w]); + } +} + /* Print all cpuid feature names in featureset */ static void listflags(FILE *f, fprintf_function print, const char **featureset) @@ -2134,40 +2168,6 @@ static uint32_t x86_cpu_get_supported_feature_word(FeatureWord w, return r; } -/* - * Filters CPU feature words based on host availability of each feature. - * - * Returns: 0 if all flags are supported by the host, non-zero otherwise. - */ -static int x86_cpu_filter_features(X86CPU *cpu) -{ - CPUX86State *env = &cpu->env; - FeatureWord w; - int rv = 0; - - for (w = 0; w < FEATURE_WORDS; w++) { - uint32_t host_feat = - x86_cpu_get_supported_feature_word(w, cpu->migratable); - uint32_t requested_features = env->features[w]; - env->features[w] &= host_feat; - cpu->filtered_features[w] = requested_features & ~env->features[w]; - if (cpu->filtered_features[w]) { - rv = 1; - } - } - - return rv; -} - -static void x86_cpu_report_filtered_features(X86CPU *cpu) -{ - FeatureWord w; - - for (w = 0; w < FEATURE_WORDS; w++) { - report_unavailable_features(w, cpu->filtered_features[w]); - } -} - static void x86_cpu_apply_props(X86CPU *cpu, PropValue *props) { PropValue *pv; -- 2.5.5

Eduardo Habkost <ehabkost(a)redhat.com&gt; writes: Can @unavailable-features be empty or missing when @runnable is true?

On Mon, May 09, 2016 at 10:54:53AM +0200, David Hildenbrand wrote: Even on those cases, can't the root cause be mapped to a QOM property name (e.g. "cpu-generation"), even if it's property that can't be changed by the user? We could replace this with something more generic, like: @runnability-blockers: List of attributes that prevent the CPU model from running in the current host. A list of QOM property names that represent CPU model attributes that prevent the CPU from running. If the QOM property is read-only, that means the CPU model can never run in the current host. If the property is read-write, it means that it MAY be possible to run the CPU model in the current host if that property is changed. Management software can use it as hints to suggest or choose an alternative for the user, or just to generate meaningful error messages explaining why the CPU model can't be used. (I am looking for a better name than "runnability-blockers"). -- Eduardo

On Mon, May 09, 2016 at 02:05:05PM +0200, David Hildenbrand wrote: But it could be implemented by s390x in the future, if it's considered useful, right? I understand it would be enough, but I would like to at least define semantics that would make sense for all architectures in case it gets implemented in the future. Would the proposal below make sense? -- Eduardo

On Mon, May 09, 2016 at 09:20:15AM -0600, Eric Blake wrote: Oops! I meant 2.7, and I didn't notice that it was not using the typical format. I will fix it, thanks. It is optional because not all architectures will return the field. This series implements it only for x86. -- Eduardo

On Tue, May 10, 2016 at 10:23:16 +0200, Markus Armbruster wrote: I think it would be a bug if missing runnable had the same meaning as runnable=false. To maintain backward compatibility with older QEMU missing runnable should mean the CPU may or may not be runnable, i.e., we don't know which and the user has to try to figure it out. Jirka

Eduardo Habkost <ehabkost(a)redhat.com&gt; writes: Please clarify that in the docs. Here's my try: # @runnable: #optional whether the CPU model us usable with the current # machine and accelerator, only present if we know (since 2.6)

This makes the feature name tables in feature_word_info all match the actual QOM property names we use. This will make the command-line interface more consistent, allowing the QOM property names to be used as "-cpu" arguments directly. Add extra feat2prop() calls to x86_cpu_parse_featurestr() to keep compatibility with the old that had underscores. Cc: Jiri Denemark <jdenemar(a)redhat.com&gt; Cc: libvir-list(a)redhat.com Signed-off-by: Eduardo Habkost <ehabkost(a)redhat.com&gt; --- target-i386/cpu.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/target-i386/cpu.c b/target-i386/cpu.c index 309ef55..e7365d1 100644 --- a/target-i386/cpu.c +++ b/target-i386/cpu.c @@ -187,7 +187,7 @@ static const char *feature_name[] = { }; static const char *ext_feature_name[] = { "pni|sse3" /* Intel,AMD sse3 */, "pclmulqdq|pclmuldq", "dtes64", "monitor", - "ds_cpl", "vmx", "smx", "est", + "ds-cpl", "vmx", "smx", "est", "tm2", "ssse3", "cid", NULL, "fma", "cx16", "xtpr", "pdcm", NULL, "pcid", "dca", "sse4.1|sse4_1", @@ -207,17 +207,17 @@ static const char *ext2_feature_name[] = { NULL /* mtrr */, NULL /* pge */, NULL /* mca */, NULL /* cmov */, NULL /* pat */, NULL /* pse36 */, NULL, NULL /* Linux mp */, "nx|xd", NULL, "mmxext", NULL /* mmx */, - NULL /* fxsr */, "fxsr_opt|ffxsr", "pdpe1gb" /* AMD Page1GB */, "rdtscp", + NULL /* fxsr */, "fxsr-opt|ffxsr", "pdpe1gb" /* AMD Page1GB */, "rdtscp", NULL, "lm|i64", "3dnowext", "3dnow", }; static const char *ext3_feature_name[] = { - "lahf_lm" /* AMD LahfSahf */, "cmp_legacy", "svm", "extapic" /* AMD ExtApicSpace */, + "lahf-lm" /* AMD LahfSahf */, "cmp-legacy", "svm", "extapic" /* AMD ExtApicSpace */, "cr8legacy" /* AMD AltMovCr8 */, "abm", "sse4a", "misalignsse", "3dnowprefetch", "osvw", "ibs", "xop", "skinit", "wdt", NULL, "lwp", - "fma4", "tce", NULL, "nodeid_msr", - NULL, "tbm", "topoext", "perfctr_core", - "perfctr_nb", NULL, NULL, NULL, + "fma4", "tce", NULL, "nodeid-msr", + NULL, "tbm", "topoext", "perfctr-core", + "perfctr-nb", NULL, NULL, NULL, NULL, NULL, NULL, NULL, }; @@ -233,8 +233,8 @@ static const char *ext4_feature_name[] = { }; static const char *kvm_feature_name[] = { - "kvmclock", "kvm_nopiodelay", "kvm_mmu", "kvmclock", - "kvm_asyncpf", "kvm_steal_time", "kvm_pv_eoi", "kvm_pv_unhalt", + "kvmclock", "kvm-nopiodelay", "kvm-mmu", "kvmclock", + "kvm-asyncpf", "kvm-steal-time", "kvm-pv-eoi", "kvm-pv-unhalt", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, @@ -244,9 +244,9 @@ static const char *kvm_feature_name[] = { }; static const char *svm_feature_name[] = { - "npt", "lbrv", "svm_lock", "nrip_save", - "tsc_scale", "vmcb_clean", "flushbyasid", "decodeassists", - NULL, NULL, "pause_filter", NULL, + "npt", "lbrv", "svm-lock", "nrip-save", + "tsc-scale", "vmcb-clean", "flushbyasid", "decodeassists", + NULL, NULL, "pause-filter", NULL, "pfthreshold", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, @@ -255,7 +255,7 @@ static const char *svm_feature_name[] = { }; static const char *cpuid_7_0_ebx_feature_name[] = { - "fsgsbase", "tsc_adjust", NULL, "bmi1", "hle", "avx2", NULL, "smep", + "fsgsbase", "tsc-adjust", NULL, "bmi1", "hle", "avx2", NULL, "smep", "bmi2", "erms", "invpcid", "rtm", NULL, NULL, "mpx", NULL, "avx512f", NULL, "rdseed", "adx", "smap", NULL, "pcommit", "clflushopt", "clwb", NULL, "avx512pf", "avx512er", "avx512cd", NULL, NULL, NULL, @@ -1894,8 +1894,8 @@ static PropertyInfo qdev_prop_spinlocks = { .set = x86_set_hv_spinlocks, }; -/* Convert all '_' in a feature string option name to '-', to make feature - * name conform to QOM property naming rule, which uses '-' instead of '_'. +/* Convert all '_' in a feature string option name to '-', to keep compatibility + * with old feature names that used "_" instead of "-". */ static inline void feat2prop(char *s) { @@ -1925,8 +1925,10 @@ static void x86_cpu_parse_featurestr(CPUState *cs, char *features, while (featurestr) { char *val; if (featurestr[0] == '+') { + feat2prop(featurestr); add_flagname_to_bitmaps(featurestr + 1, plus_features, &local_err); } else if (featurestr[0] == '-') { + feat2prop(featurestr); add_flagname_to_bitmaps(featurestr + 1, minus_features, &local_err); } else if ((val = strchr(featurestr, '='))) { *val = 0; val++; @@ -3137,11 +3139,9 @@ static void x86_cpu_register_feature_bit_props(X86CPU *cpu, names = g_strsplit(fi->feat_names[bitnr], "|", 0); - feat2prop(names[0]); x86_cpu_register_bit_prop(cpu, names[0], &cpu->env.features[w], bitnr); for (i = 1; names[i]; i++) { - feat2prop(names[i]); object_property_add_alias(obj, names[i], obj, names[0], &error_abort); } -- 2.5.5

On Tue, May 24, 2016 at 02:17:03PM +0200, Igor Mammedov wrote: A previous version of this patch had it. But it would change the property value too, not just the property name (breaking stuff like "model-id=some_string"). -- Eduardo

On Tue, May 24, 2016 at 03:22:27PM +0200, Igor Mammedov wrote: [...] The comment above it doesn't say anything about stopping at a '=' delimiter. I always expected it to just replace "_" with "-" in a null-terminated string. (I am not completely against making it stop at '=', but I believe your suggestion below sounds better). This would make "+feature=FOO" treated as a valid option, and it isn't. It would keep the existing behavior if we did this: - if (featurestr[0] == '+') { + if (featurestr[0] == '+' && !val) { add_flagname_to_bitmaps(featurestr + 1, plus_features, &local_err); - } else if (featurestr[0] == '-') { + if (featurestr[0] == '+' && !val) { add_flagname_to_bitmaps(featurestr + 1, minus_features, &local_err); In either case, I prefer to get this optimization reviewed as a separate patch. Can you send it as a follow-up? -- Eduardo

Fill the "runnable" and "unavailable-features" fields on the x86 implementation of query-cpu-definitions. Example command output: { "return": [ { "runnable": true, "name": "host"}, { "runnable": true, "name": "qemu64"}, { "runnable": true, "name": "qemu32"}, { "runnable": false, "name": "phenom", "unavailable-features": ["npt", "sse4a", "3dnow", "3dnowext", "fxsr-opt", "mmxext"] }, { "runnable": true, "name": "pentium3"}, { "runnable": true, "name": "pentium2"}, { "runnable": true, "name": "pentium"}, { "runnable": true, "name": "n270"}, { "runnable": true, "name": "kvm64"}, { "runnable": true, "name": "kvm32"}, { "runnable": true, "name": "coreduo"}, { "runnable": true, "name": "core2duo"}, { "runnable": false, "name": "athlon", "unavailable-features": ["3dnow", "3dnowext", "mmxext"] }, { "runnable": true, "name": "Westmere"}, { "runnable": true, "name": "SandyBridge"}, { "runnable": true, "name": "Penryn"}, { "runnable": false, "name": "Opteron_G5", "unavailable-features": ["tbm", "fma4", "xop", "3dnowprefetch", "misalignsse", "sse4a"] }, { "runnable": false, "name": "Opteron_G4", "unavailable-features": ["fma4", "xop", "3dnowprefetch", "misalignsse", "sse4a"] }, { "runnable": false, "name": "Opteron_G3", "unavailable-features": ["misalignsse", "sse4a"] }, { "runnable": true, "name": "Opteron_G2"}, { "runnable": true, "name": "Opteron_G1"}, { "runnable": true, "name": "Nehalem"}, { "runnable": true, "name": "IvyBridge"}, { "runnable": false, "name": "Haswell", "unavailable-features": ["rtm", "hle"] }, { "runnable": true, "name": "Haswell-noTSX"}, { "runnable": true, "name": "Conroe"}, { "runnable": false, "name": "Broadwell", "unavailable-features": ["3dnowprefetch", "smap", "adx", "rdseed", "rtm", "hle"] }, { "runnable": false, "name": "Broadwell-noTSX", "unavailable-features": ["3dnowprefetch", "smap", "adx", "rdseed"] }, { "runnable": true, "name": "486"} ] } Cc: Jiri Denemark <jdenemar(a)redhat.com&gt; Cc: libvir-list(a)redhat.com Signed-off-by: Eduardo Habkost <ehabkost(a)redhat.com&gt; --- target-i386/cpu.c | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/target-i386/cpu.c b/target-i386/cpu.c index e7365d1..f6f0f83 100644 --- a/target-i386/cpu.c +++ b/target-i386/cpu.c @@ -2041,6 +2041,41 @@ static void x86_cpu_report_filtered_features(X86CPU *cpu) } } +static bool x86_cpu_class_is_runnable(X86CPUClass *xcc, strList **missing_feats) +{ + X86CPU *xc; + bool r; + FeatureWord w; + + if (xcc->kvm_required && !kvm_enabled()) { + return false; + } + + xc = X86_CPU(object_new(object_class_get_name(OBJECT_CLASS(xcc)))); + r = !x86_cpu_filter_features(xc); + if (!r) { + for (w = 0; w < FEATURE_WORDS; w++) { + FeatureWordInfo *fi = &feature_word_info[w]; + uint32_t filtered = xc->filtered_features[w]; + int i; + for (i = 0; i < 32; i++) { + if (filtered & (1UL << i)) { + char **parts = g_strsplit(fi->feat_names[i], "|", 2); + strList *new = g_new0(strList, 1); + new->value = g_strdup(parts[0]); + feat2prop(new->value); + new->next = *missing_feats; + *missing_feats = new; + g_strfreev(parts); + } + } + } + } + + object_unref(OBJECT(xc)); + return r; +} + /* Print all cpuid feature names in featureset */ static void listflags(FILE *f, fprintf_function print, const char **featureset) @@ -2133,6 +2168,11 @@ static void x86_cpu_definition_entry(gpointer data, gpointer user_data) info = g_malloc0(sizeof(*info)); info->name = x86_cpu_class_get_model_name(cc); + info->has_runnable = true; + info->runnable = x86_cpu_class_is_runnable(cc, &info->unavailable_features); + if (!info->runnable) { + info->has_unavailable_features = true; + } entry = g_malloc0(sizeof(*entry)); entry->value = info; -- 2.5.5