Support QEMU cpu models in MSHV accelerator
v6 cover Support QEMU cpu models in MSHV accelerator
Hey all,
In the current MSHV accelerator code passing CPU features via the -cpu flag doesn't work as intended yet. When using the MSHV hypervisor we either silently discard the specified model/features and leave it up to the hypervisor to provide a sensible set of features or if the user selects -cpu host, the hypervisor might refuse to create a partition.
This changeset introduces a more comprehensive support for passing desired guest cpu features to the hypervisor. It's also a prerequisite for Live Migration support.
Changes since v5:
- Remove leftover masking of CET shadowstack bit
Changes since v4:
- Use hypervisor-provided values in CPUID[0xD,{1,2}].EBX to get proper XSAVE sizes via EBX mask:
- Drop masking of CET feature bits (workaround not required anymore)
Changes since v3:
- Rebased onto current master
Changes since v2:
- move disabling of la57 to arch specific code
- assert MSHV_NUM_CPU_FEATURES_BANKS == 2
- dropped QEMU_PACKED changes to hv headers (address in individal patch)
Changes since v1:
- query hypervisor for supported processor features instead of the host OS
- disable la57 (5 level page tables)
best,
magnus
Magnus Kulke (9):
accel/mshv: use mshv_create_partition_v2 payload target/i386/mshv: fix cpuid propagation bug target/i386/mshv: fix various cpuid traversal bugs target/i386/mshv: change cpuid mask to UINT32_MAX target/i386/mshv: set cpu model name on -cpu host target/i386: query mshv accel for supported cpuids target/i386/mshv: populate xsave area offsets target/i386/mshv: use hv-provided [0xD,1+2].EBX accel/mshv: disable la57 (5lvl paging)
accel/mshv/mshv-all.c | 78 ++++++++++- include/hw/hyperv/hvgdk_mini.h | 2 + include/hw/hyperv/hvhdk.h | 195 +++++++++++++++++++++++++++ include/system/mshv.h | 3 + include/system/mshv_int.h | 2 + target/i386/cpu.c | 8 ++ target/i386/mshv/mshv-cpu.c | 238 +++++++++++++++++++++++++++------ 7 files changed, 476 insertions(+), 50 deletions(-)
Signature · 1 line
2.34.1
PATCH v6 1/9 accel/mshv: use mshv_create_partition_v2 payload
When using the extended request format we can instruct the hypervisor to provision enough space for requested XSAVE features. This is required for supporting QEMU models provided via the -cpu flag properly.
--- accel/mshv/mshv-all.c | 71 ++++++++++-- include/hw/hyperv/hvgdk_mini.h | 2 + include/hw/hyperv/hvhdk.h | 195 +++++++++++++++++++++++++++++++++ 3 files changed, 261 insertions(+), 7 deletions(-)
accel/mshv/mshv-all.c +64 -7
@@ -110,21 +110,78 @@ static int resume_vm(int vm_fd)return 0 ; } +static int get_host_partition_property (int mshv_fd,uint32_t property_code, +uint64_t *value) +{ +int ret; +struct hv_input_get_partition_property in = {0 }; +struct hv_output_get_partition_property out = {0 }; +struct mshv_root_hvcall args = {0 }; + + in.property_code = property_code; + + args.code =HVCALL_GET_PARTITION_PROPERTY ; + args.in_sz =sizeof (in); + args.in_ptr = (uint64_t )∈ + args.out_sz =sizeof (out); + args.out_ptr = (uint64_t )&out; + + ret =ioctl (mshv_fd,MSHV_ROOT_HVCALL , &args); +if (ret <0 ) { +error_report ("Failed to get host partition property bank: %s" , +strerror (errno)); +return -1 ; + } + + *value = out.property_value; +return 0 ; +} +static int create_partition (int mshv_fd,int *vm_fd) {int ret; -struct mshv_create_partition args = {0 }; +uint64_t pt_flags, host_proc_features; +union hv_partition_processor_xsave_features disabled_xsave_features; +struct mshv_create_partition_v2 args = {0 }; + +QEMU_BUILD_BUG_ON (MSHV_NUM_CPU_FEATURES_BANKS !=2 );/* Initialize pt_flags with the desired features */ -uint64_t pt_flags = (1ULL <<MSHV_PT_BIT_LAPIC ) | - (1ULL <<MSHV_PT_BIT_X2APIC ) | - (1ULL <<MSHV_PT_BIT_GPA_SUPER_PAGES ); + pt_flags = (1ULL <<MSHV_PT_BIT_LAPIC ) | + (1ULL <<MSHV_PT_BIT_X2APIC ) | + (1ULL <<MSHV_PT_BIT_GPA_SUPER_PAGES ) | + (1ULL <<MSHV_PT_BIT_CPU_AND_XSAVE_FEATURES ); + +/* enable all */ + disabled_xsave_features.as_uint64 =0 ; + +/* +* query host for supported processor features and disable unsupported +* features: (0 means supported, 1 means disabled, hence the negation) +*/ + ret =get_host_partition_property (mshv_fd, +HV_PARTITION_PROPERTY_PROCESSOR_FEATURES0 , + &host_proc_features); +if (ret <0 ) { +error_report ("Failed to get host processor feature bank 0" ); +return -1 ; + } + args.pt_cpu_fbanks[0 ] = ~host_proc_features; -/* Set default isolation type */ -uint64_t pt_isolation =MSHV_PT_ISOLATION_NONE ; + ret =get_host_partition_property (mshv_fd, +HV_PARTITION_PROPERTY_PROCESSOR_FEATURES1 , + &host_proc_features); +if (ret <0 ) { +error_report ("Failed to get host processor feature bank 1" ); +return -1 ; + } + args.pt_cpu_fbanks[1 ] = ~host_proc_features; +/* populate args structure */ args.pt_flags = pt_flags; - args.pt_isolation = pt_isolation; + args.pt_isolation =MSHV_PT_ISOLATION_NONE ; + args.pt_disabled_xsave = disabled_xsave_features.as_uint64; + args.pt_num_cpu_fbanks =MSHV_NUM_CPU_FEATURES_BANKS ; ret =ioctl (mshv_fd,MSHV_CREATE_PARTITION , &args);if (ret <0 ) {
include/hw/hyperv/hvgdk_mini.h +2 -0
@@ -454,6 +454,8 @@ typedef struct hv_input_set_vp_registers {struct hv_register_assoc elements[]; }QEMU_PACKED hv_input_set_vp_registers; +#define MSHV_VP_MAX_REGISTERS 128 +union hv_interrupt_control {uint64_t as_uint64;struct {
include/hw/hyperv/hvhdk.h +195 -0
207 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH v6 1/9] accel/mshv: use mshv_create_partition_v2 payload
Quoted 4 lines · Magnus Kulke
When using the extended request format we can instruct the hypervisor to provision enough space for requested XSAVE features. This is required for supporting QEMU models provided via the -cpu flag properly.
Quoted 8 lines
Signed-off-by Magnus Kulke <[email protected]>Acked-by Wei Liu <[email protected]>--- accel/mshv/mshv-all.c | 71 ++++++++++-- include/hw/hyperv/hvgdk_mini.h | 2 + include/hw/hyperv/hvhdk.h | 195 +++++++++++++++++++++++++++++++++ 3 files changed, 261 insertions(+), 7 deletions(-)
PATCH v6 2/9 target/i386/mshv: fix cpuid propagation bug
In reply to Magnus KulkeThe list argument was missing a pointer and hence e.g. -cpu qemu64 and -cpu EPYC would produce the same of cpuid leaves.
--- target/i386/mshv/mshv-cpu.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
target/i386/mshv/mshv-cpu.c +4 -4
@@ -441,7 +441,7 @@ int mshv_load_regs(CPUState *cpu)return 0 ; } -static void add_cpuid_entry (GList *cpuid_entries, +static void add_cpuid_entry (GList **cpuid_entries,uint32_t function,uint32_t index,uint32_t eax,uint32_t ebx,uint32_t ecx,uint32_t edx)
@@ -456,10 +456,10 @@ static void add_cpuid_entry(GList *cpuid_entries, entry->ecx = ecx; entry->edx = edx; - cpuid_entries =g_list_append (cpuid_entries, entry); + *cpuid_entries =g_list_append (*cpuid_entries, entry); } -static void collect_cpuid_entries (const CPUState *cpu,GList *cpuid_entries) +static void collect_cpuid_entries (const CPUState *cpu,GList **cpuid_entries) {X86CPU *x86_cpu =X86_CPU (cpu);CPUX86State *env = &x86_cpu->env;
@@ -615,7 +615,7 @@ static int set_cpuid2(const CPUState *cpu)struct hv_cpuid_entry *entry;GList *entries =NULL ; -collect_cpuid_entries (cpu, entries); +collect_cpuid_entries (cpu, &entries); n_entries =g_list_length (entries); cpuid_size =sizeof (struct hv_cpuid )
Signature · 1 line
2.34.1
Re: [PATCH v6 2/9] target/i386/mshv: fix cpuid propagation bug
Quoted 11 lines · Magnus Kulke
The list argument was missing a pointer and hence e.g. -cpu qemu64 and -cpu EPYC would produce the same of cpuid leaves.
Fixes 4fa04dd1621 ("target/i386: Register CPUID entries with MSHV")Signed-off-by Magnus Kulke <[email protected]>Reviewed-by Philippe Mathieu-Daudé <[email protected]>--- target/i386/mshv/mshv-cpu.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
Re: [PATCH v6 2/9] target/i386/mshv: fix cpuid propagation bug
In reply to Magnus KulkeQuoted 11 lines · Magnus Kulke
The list argument was missing a pointer and hence e.g. -cpu qemu64 and -cpu EPYC would produce the same of cpuid leaves.
Fixes 4fa04dd1621 ("target/i386: Register CPUID entries with MSHV")Signed-off-by Magnus Kulke <[email protected]>Reviewed-by Philippe Mathieu-Daudé <[email protected]>--- target/i386/mshv/mshv-cpu.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
Hi!
Is this a qemu-stable material (11.0.x)?
I'm not sure how matur mshww is to begin with, whenever it is worth to consider for the stable series.
Thanks,
/mjt
Re: [PATCH v6 2/9] target/i386/mshv: fix cpuid propagation bug
Il dom 28 giu 2026, 13:24 Michael Tokarev <[email protected]> ha scritto:
Quoted 6 lines
Hi!
Is this a qemu-stable material (11.0.x)?
I'm not sure how matur mshww is to begin with, whenever it is worth to consider for the stable series.
I am not even sure anyone can run it outside Microsoft... That's probably a no ;)
Paolo
Quoted 5 lines
Thanks,
/mjt
Re: [PATCH v6 2/9] target/i386/mshv: fix cpuid propagation bug
Quoted 9 lines · Paolo Bonzini
Il dom 28 giu 2026, 13:24 Michael Tokarev <[email protected]> ha scritto:
Quoted 6 lines
Hi!
Is this a qemu-stable material (11.0.x)?
I'm not sure how matur mshww is to begin with, whenever it is worth to consider for the stable series.
Quoted 11 lines
I am not even sure anyone can run it outside Microsoft... That's probably a no ;)
Paolo
Quoted 5 lines
Thanks,
/mjt
yup, I would concur. theoretically yes - it does fix a bug that exists on the stable release, but the bug only surfaces for -cpu host model selection, which will only be supported in a future release (with the patch series of which this commit is a part of).
best,
magnus
PATCH v6 3/9 target/i386/mshv: fix various cpuid traversal bugs
In reply to Magnus Kulke- Hardcoded max_leaf was not accurate. We query leaf 0x0 and 0x80000000 to get the actual max leaves
- On all 0 zeroes on leaf 0x0d, we register 0-63 subleaves with zeros indicating XSAVE is disabled
- Subleaf 0 was hardcoded, so the Hypervisor returned defaults for other subleaves
- Subleaf 0 was hardcoded, so we were passing 0 instead of actual subleaf when adding entries. We now pass the correct subleaf value to add_cpuid_entry()
- Leaves 0x04,0x07,0d,0f,10 weren't marked as subleaf-specific
--- target/i386/mshv/mshv-cpu.c | 88 +++++++++++++++++++++++++------------ 1 file changed, 61 insertions(+), 27 deletions(-)
target/i386/mshv/mshv-cpu.c +61 -27
@@ -465,14 +465,17 @@ static void collect_cpuid_entries(const CPUState *cpu, GList **cpuid_entries)CPUX86State *env = &x86_cpu->env;uint32_t eax, ebx, ecx, edx;uint32_t leaf, subleaf; -size_t max_leaf =0x1F ; -size_t max_subleaf =0x20 ; - -uint32_t leaves_with_subleaves[] = {0x4 ,0x7 ,0xD ,0xF ,0x10 }; +uint32_t max_basic_leaf, max_extended_leaf; +uint32_t max_subleaf =0x20 ; +uint32_t leaves_with_subleaves[] = {0x04 ,0x07 ,0x0d ,0x0f ,0x10 };int n_subleaf_leaves =ARRAY_SIZE (leaves_with_subleaves); -/* Regular leaves without subleaves */ -for (leaf =0 ; leaf <= max_leaf; leaf++) { +/* Get maximum basic and and extended CPUID leaves */ +cpu_x86_cpuid (env,0 ,0 , &max_basic_leaf, &ebx, &ecx, &edx); +cpu_x86_cpuid (env,0x80000000 ,0 , &max_extended_leaf, &ebx, &ecx, &edx); + +/* Collect basic leaves (0x0 to max_basic_leaf) */ +for (leaf =0 ; leaf <= max_basic_leaf; leaf++) {bool has_subleaves = false;for (int i =0 ; i < n_subleaf_leaves; i++) {if (leaf == leaves_with_subleaves[i]) {
@@ -483,27 +486,40 @@ static void collect_cpuid_entries(const CPUState *cpu, GList **cpuid_entries)if (!has_subleaves) {cpu_x86_cpuid (env, leaf,0 , &eax, &ebx, &ecx, &edx); -if (eax ==0 && ebx ==0 && ecx ==0 && edx ==0 ) { -/* all zeroes indicates no more leaves */ -continue ; - } -add_cpuid_entry (cpuid_entries, leaf,0 , eax, ebx, ecx, edx);continue ; } +/* +* Valid XSAVE components can exist at a higher index se we need to set +* all subleaves for leaf 0x0d, even if we encounter an empty one. +*/ +if (leaf ==0x0d ) { +for (subleaf =0 ; subleaf <=63 ; subleaf++) { +cpu_x86_cpuid (env, leaf, subleaf, &eax, &ebx, &ecx, &edx); +add_cpuid_entry (cpuid_entries, leaf, subleaf, + eax, ebx, ecx, edx); + } +continue ; + } + subleaf =0 ;while (subleaf < max_subleaf) {cpu_x86_cpuid (env, leaf, subleaf, &eax, &ebx, &ecx, &edx);if (eax ==0 && ebx ==0 && ecx ==0 && edx ==0 ) { -/* all zeroes indicates no more leaves */ break ; } -add_cpuid_entry (cpuid_entries, leaf,0 , eax, ebx, ecx, edx); +add_cpuid_entry (cpuid_entries, leaf, subleaf, eax, ebx, ecx, edx); subleaf++; } } + +/* Collect extended leaves (0x80000000 to max_extended_leaf) */ +for (leaf =0x80000000 ; leaf <= max_extended_leaf; leaf++) { +cpu_x86_cpuid (env, leaf,0 , &eax, &ebx, &ecx, &edx); +add_cpuid_entry (cpuid_entries, leaf,0 , eax, ebx, ecx, edx); + } } static int register_intercept_result_cpuid_entry(const CPUState *cpu,
@@ -576,22 +592,40 @@ static int register_intercept_result_cpuid(const CPUState *cpu, subleaf_specific =0 ; always_override =1 ; -/* Intel */ -/* 0xb - Extended Topology Enumeration Leaf */ -/* 0x1f - V2 Extended Topology Enumeration Leaf */ -/* AMD */ -/* 0x8000_001e - Processor Topology Information */ -/* 0x8000_0026 - Extended CPU Topology */ -if (entry->function ==0xb - || entry->function ==0x1f - || entry->function ==0x8000001e - || entry->function ==0x80000026 ) { +/* +* Intel +* 0xb - Extended Topology Enumeration Leaf +* 0x1f - V2 Extended Topology Enumeration Leaf +* AMD +* 0x8000_001e - Processor Topology Information +* 0x8000_0026 - Extended CPU Topology +*/ +if (entry->function ==0xb || + entry->function ==0x1f || + entry->function ==0x8000001e || + entry->function ==0x80000026 ) { + subleaf_specific =1 ; + always_override =1 ; +/* +* Feature enumeration leaves (subleaf-specific) +* 0x04: Deterministic Cache Parameters +* 0x07: Structured Extended Feature Flags +* 0x0D: Processor Extended State Enumeration +* 0x0F: Platform QoS Monitoring +* 0x10: Platform QoS Enforcement +*/ + }else if (entry->function ==0x04 || + entry->function ==0x07 || + entry->function ==0x0d || + entry->function ==0x0f || + entry->function ==0x10 ) { subleaf_specific =1 ; always_override =1 ; - }else if (entry->function ==0x00000001 - || entry->function ==0x80000000 - || entry->function ==0x80000001 - || entry->function ==0x80000008 ) { +/* Basic feature leaves (no subleaves) */ + }else if (entry->function ==0x00000001 || + entry->function ==0x80000000 || + entry->function ==0x80000001 || + entry->function ==0x80000008 ) { subleaf_specific =0 ; always_override =1 ; }
Signature · 1 line
2.34.1
Re: [PATCH v6 3/9] target/i386/mshv: fix various cpuid traversal bugs
Quoted 13 lines · Magnus Kulke
- Hardcoded
max_leafwas not accurate. We query leaf0x0and0x80000000to get the actual max leaves- On all 0 zeroes on leaf
0x0d, we register 0-63 subleaves with zeros indicating XSAVE is disabled- Subleaf 0 was hardcoded, so the Hypervisor returned defaults for other subleaves
- Subleaf 0 was hardcoded, so we were passing 0 instead of actual subleaf when adding entries. We now pass the correct subleaf value to
add_cpuid_entry()
Quoted 7 lines
- Leaves 0x04,0x07,0d,0f,10 weren't marked as subleaf-specific
Signed-off-by Magnus Kulke <[email protected]>Acked-by Wei Liu <[email protected]>--- target/i386/mshv/mshv-cpu.c | 88 +++++++++++++++++++++++++------------ 1 file changed, 61 insertions(+), 27 deletions(-)
PATCH v6 4/9 target/i386/mshv: change cpuid mask to UINT32_MAX
In reply to Magnus KulkeThe current implementation would only override the feature bits that are enabled, however we also want to consider disabled features, hence all bits are set on the masks in the hypercall argument.
--- target/i386/mshv/mshv-cpu.c | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-)
target/i386/mshv/mshv-cpu.c +6 -11
@@ -538,22 +538,17 @@ static int register_intercept_result_cpuid_entry(const CPUState *cpu, .input.always_override = always_override, .input.padding = 0,/* -* With regard to masks - these are to specify bits to be overwritten -* The current CpuidEntry structure wouldn't allow to carry the masks -* in addition to the actual register values. For this reason, the -* masks are set to the exact values of the corresponding register bits -* to be registered for an overwrite. To view resulting values the -* hypervisor would return, HvCallGetVpCpuidValues hypercall can be -* used. +* Masks specify which bits to override. Set to 0xFFFFFFFF to +* override all bits with the values from the QEMU CPU model. */ .result.eax = entry->eax, - .result.eax_mask = entry->eax, + .result.eax_mask = 0xFFFFFFFF, .result.ebx = entry->ebx, - .result.ebx_mask = entry->ebx, + .result.ebx_mask = 0xFFFFFFFF, .result.ecx = entry->ecx, - .result.ecx_mask = entry->ecx, + .result.ecx_mask = 0xFFFFFFFF, .result.edx = entry->edx, - .result.edx_mask = entry->edx, + .result.edx_mask = 0xFFFFFFFF, };union hv_register_intercept_result_parameters parameters = { .cpuid = cpuid_params,
Signature · 1 line
2.34.1
Re: [PATCH v6 4/9] target/i386/mshv: change cpuid mask to UINT32_MAX
Quoted 10 lines · Magnus Kulke
The current implementation would only override the feature bits that are enabled, however we also want to consider disabled features, hence all bits are set on the masks in the hypercall argument.
Signed-off-by Magnus Kulke <[email protected]>Acked-by Wei Liu <[email protected]>--- target/i386/mshv/mshv-cpu.c | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-)
PATCH v6 5/9 target/i386/mshv: set cpu model name on -cpu host
In reply to Magnus KulkeBy registering a cpu_accel_class for mshv, we can report an accurate model name on -cpu host.
--- target/i386/mshv/mshv-cpu.c | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+)
target/i386/mshv/mshv-cpu.c +31 -0
@@ -24,10 +24,13 @@#include "hw/i386/apic_internal.h" #include "cpu.h" +#include "host-cpu.h" #include "emulate/x86_decode.h" #include "emulate/x86_emu.h" #include "emulate/x86_flags.h" +#include "accel/accel-cpu-target.h" +#include "trace-accel_mshv.h" #include "trace.h"
@@ -1675,3 +1678,31 @@ int mshv_arch_post_init_vm(int vm_fd)return ret; } + +static void mshv_cpu_instance_init (CPUState *cs) +{ +X86CPU *cpu =X86_CPU (cs); + +host_cpu_instance_init (cpu); +} + +static void mshv_cpu_accel_class_init (ObjectClass *oc,const void *data) +{ +AccelCPUClass *acc =ACCEL_CPU_CLASS (oc); + + acc->cpu_instance_init = mshv_cpu_instance_init; +} + +static const TypeInfo mshv_cpu_accel_type_info = { + .name =ACCEL_CPU_NAME ("mshv" ), + .parent =TYPE_ACCEL_CPU , + .class_init = mshv_cpu_accel_class_init, + .abstract = true, +}; + +static void mshv_cpu_accel_register_types (void ) +{ +type_register_static (&mshv_cpu_accel_type_info); +} + +type_init (mshv_cpu_accel_register_types);
Signature · 1 line
2.34.1
Re: [PATCH v6 5/9] target/i386/mshv: set cpu model name on -cpu host
Quoted 9 lines · Magnus Kulke
By registering a
cpu_accel_classfor mshv, we can report an accurate model name on -cpu host.Signed-off-by Magnus Kulke <[email protected]>Acked-by Wei Liu <[email protected]>--- target/i386/mshv/mshv-cpu.c | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+)
PATCH v6 6/9 target/i386: query mshv accel for supported cpuids
In reply to Magnus KulkeWe implement mshv_get_supported_cpuid() and invoke it in x86_cpu_get_supported_feature_word() retrieve the cpu features that the host is supporting. Initially we mask the virtualization capabilitities potentially we might need to mask more in the future.
--- include/system/mshv.h | 3 +++ target/i386/cpu.c | 8 ++++++++ target/i386/mshv/mshv-cpu.c | 27 +++++++++++++++++++++++++++ 3 files changed, 38 insertions(+)
include/system/mshv.h +3 -0
@@ -60,4 +60,7 @@ int mshv_irqchip_add_irqfd_notifier_gsi(const EventNotifier *n, const EventNotifier *rn, int virq);int mshv_irqchip_remove_irqfd_notifier_gsi (const EventNotifier *n,int virq); +/* cpuid */ +uint32_t mshv_get_supported_cpuid (uint32_t func,uint32_t idx,int reg); +#endif
target/i386/cpu.c +8 -0
@@ -26,6 +26,7 @@#include "tcg/helper-tcg.h" #include "exec/translation-block.h" #include "system/hvf.h" +#include "system/mshv.h" #include "hvf/hvf-i386.h" #include "kvm/kvm_i386.h" #include "kvm/tdx.h"
@@ -8087,6 +8088,13 @@ uint64_t x86_cpu_get_supported_feature_word(X86CPU *cpu, FeatureWord w) r =hvf_get_supported_cpuid (wi->cpuid.eax, wi->cpuid.ecx, wi->cpuid.reg); + }else if (mshv_enabled ()) { +if (wi->type !=CPUID_FEATURE_WORD ) { +return 0 ; + } + r =mshv_get_supported_cpuid (wi->cpuid.eax, + wi->cpuid.ecx, + wi->cpuid.reg); }else if (tcg_enabled () ||qtest_enabled ()) { r = wi->tcg_features; }else {
target/i386/mshv/mshv-cpu.c +27 -0
@@ -1639,6 +1639,33 @@ void mshv_arch_destroy_vcpu(CPUState *cpu)g_clear_pointer (&env->emu_mmio_buf, g_free); } +uint32_t mshv_get_supported_cpuid (uint32_t func,uint32_t idx,int reg) +{ +uint32_t eax, ebx, ecx, edx; +uint32_t ret =0 ; + +host_cpuid (func, idx, &eax, &ebx, &ecx, &edx); +switch (reg) { +case R_EAX : + ret = eax;break ; +case R_EBX : + ret = ebx;break ; +case R_ECX : + ret = ecx;break ; +case R_EDX : + ret = edx;break ; + } + +/* Disable nested virtualization features not yet supported by MSHV */ +if (func ==0x80000001 && reg ==R_ECX ) { + ret &= ~CPUID_EXT3_SVM ; + } +if (func ==0x01 && reg ==R_ECX ) { + ret &= ~CPUID_EXT_VMX ; + } +return ret; +} +/* * Default Microsoft Hypervisor behavior for unimplemented MSR is to send a * fault to the guest if it tries to access it. It is possible to override
Signature · 1 line
2.34.1
Re: [PATCH v6 6/9] target/i386: query mshv accel for supported cpuids
Quoted 11 lines · Magnus Kulke
We implement
mshv_get_supported_cpuid()and invoke it inx86_cpu_get_supported_feature_word()retrieve the cpu features that the host is supporting. Initially we mask the virtualization capabilitities potentially we might need to mask more in the future.Signed-off-by Magnus Kulke <[email protected]>--- include/system/mshv.h | 3 +++ target/i386/cpu.c | 8 ++++++++ target/i386/mshv/mshv-cpu.c | 27 +++++++++++++++++++++++++++ 3 files changed, 38 insertions(+)
Re: [PATCH v6 6/9] target/i386: query mshv accel for supported cpuids
In reply to Magnus KulkeQuoted 4 lines · Magnus Kulke
We implement
mshv_get_supported_cpuid()and invoke it inx86_cpu_get_supported_feature_word()retrieve the cpu features that the host is supporting. Initially we mask the virtualization capabilitities potentially we might need to mask more in the future.
Hopefully not - the difference between what the host and the guest support is not something that QEMU can know.
Apart from that, there's nothing that stands out so I'm applying the series.
Paolo
Re: [PATCH v6 6/9] target/i386: query mshv accel for supported cpuids
Quoted 6 lines · Paolo Bonzini
Quoted 4 lines · Magnus Kulke
We implement
mshv_get_supported_cpuid()and invoke it inx86_cpu_get_supported_feature_word()retrieve the cpu features that the host is supporting. Initially we mask the virtualization capabilitities potentially we might need to mask more in the future.
Quoted 6 lines
Hopefully not - the difference between what the host and the guest support is not something that QEMU can know.
Apart from that, there's nothing that stands out so I'm applying the series.
Paolo
I think that is something that we will probably have to refine more. Intuitively I would also say that the VMM shouldn't be concerned much about host capabilities, however -cpu host has some interesting implications for a VMM that is driving msft hypervisor. I understand some features (CET I think?) would have an impact the instruction emulator. For KVM that would be in the kernel, but for MSHV (and HVF, WHPX I think) that's userland.
We're still discussing with the hypervisor and kernel team what the proper approach is, how we can reconcile cpuids with the flags that we pass at partition creation and how much awareness should exist in the VMM. I can imagine that we'll take a conservative approach and end up enumerating the features that we support in QEMU (and extend them in future releases if required).
thx,
magnus
PATCH v6 7/9 target/i386/mshv: populate xsave area offsets
In reply to Magnus KulkeThis function is copied verbatim from kvm_cpu_xsave_init(), for MSHV we need to populate the offsets similarly.
--- target/i386/mshv/mshv-cpu.c | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+)
target/i386/mshv/mshv-cpu.c +31 -0
@@ -1706,11 +1706,42 @@ int mshv_arch_post_init_vm(int vm_fd)return ret; } +static void mshv_cpu_xsave_init (void ) +{ +static bool first = true; +uint32_t eax, ebx, ecx, edx; +int i; + +if (!first) { +return ; + } + first = false; + +/* x87 and SSE states are in the legacy region of the XSAVE area. */ + x86_ext_save_areas[XSTATE_FP_BIT ].offset =0 ; + x86_ext_save_areas[XSTATE_SSE_BIT ].offset =0 ; + +for (i =XSTATE_SSE_BIT +1 ; i <XSAVE_STATE_AREA_COUNT ; i++) { +ExtSaveArea *esa = &x86_ext_save_areas[i]; + +if (!esa->size) { +continue ; + } +host_cpuid (0xd , i, &eax, &ebx, &ecx, &edx); +if (eax !=0 ) { +assert (esa->size == eax); + esa->offset = ebx; + esa->ecx = ecx; + } + } +} +static void mshv_cpu_instance_init (CPUState *cs) {X86CPU *cpu =X86_CPU (cs);host_cpu_instance_init (cpu); +mshv_cpu_xsave_init (); }static void mshv_cpu_accel_class_init (ObjectClass *oc,const void *data)
Signature · 1 line
2.34.1
Re: [PATCH v6 7/9] target/i386/mshv: populate xsave area offsets
Quoted 9 lines · Magnus Kulke
This function is copied verbatim from
kvm_cpu_xsave_init(), for MSHV we need to populate the offsets similarly.Signed-off-by Magnus Kulke <[email protected]>--- target/i386/mshv/mshv-cpu.c | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+)
PATCH v6 8/9 target/i386/mshv: use hv-provided [0xD,1+2].EBX
In reply to Magnus KulkeWe cannot statically set the responses for CPUID[0xD,{1,2}].EBX, b/c those are dynamic, dependent on which features the guest enables.
Hence we mask EBX when registering answers for those subleaves at the hypervisor, which will result in the hypervisor providing us answers, considering XCR0 and XSS.
The reported size now reflects the field masks properly (without the mask they were 576 and 10728, which is wrong):
$ cpuid -l 0xd -s 0
CPU 0:
XSAVE features (0xd/0):
XCR0 valid bit field mask = 0x00000000000600e7
...
bytes required by fields in XCR0 = 0x00002b00 (11008)
bytes required by XSAVE/XRSTOR area = 0x00002b00 (11008)$ cpuid -l 0xd -s 1
CPU 0:
XSAVE features (0xd/1):
...
SAVE area size in bytes = 0x000029c0 (10688)
IA32_XSS lower 32 bits valid bit field mask = 0x00001800
IA32_XSS upper 32 bits valid bit field mask = 0x00000000--- target/i386/mshv/mshv-cpu.c | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-)
target/i386/mshv/mshv-cpu.c +21 -2
@@ -528,6 +528,7 @@ static void collect_cpuid_entries(const CPUState *cpu, GList **cpuid_entries)static int register_intercept_result_cpuid_entry (const CPUState *cpu,uint8_t subleaf_specific,uint8_t always_override, +uint32_t ebx_mask,struct hv_cpuid_entry *entry) {int ret;
@@ -543,11 +544,12 @@ static int register_intercept_result_cpuid_entry(const CPUState *cpu,/* * Masks specify which bits to override. Set to 0xFFFFFFFF to * override all bits with the values from the QEMU CPU model. +* A mask of 0 lets the hypervisor supply its own value. */ .result.eax = entry->eax, .result.eax_mask = 0xFFFFFFFF, .result.ebx = entry->ebx, - .result.ebx_mask = 0xFFFFFFFF, + .result.ebx_mask = ebx_mask, .result.ecx = entry->ecx, .result.ecx_mask = 0xFFFFFFFF, .result.edx = entry->edx,
@@ -582,6 +584,7 @@ static int register_intercept_result_cpuid(const CPUState *cpu,int ret =0 , entry_ret;struct hv_cpuid_entry *entry;uint8_t subleaf_specific, always_override; +uint32_t ebx_mask;for (size_t i =0 ; i < cpuid->nent; i++) { entry = &cpuid->entries[i];
@@ -589,6 +592,7 @@ static int register_intercept_result_cpuid(const CPUState *cpu,/* set defaults */ subleaf_specific =0 ; always_override =1 ; + ebx_mask =0xFFFFFFFF ;/* * Intel
@@ -628,8 +632,22 @@ static int register_intercept_result_cpuid(const CPUState *cpu, always_override =1 ; } - entry_ret =register_intercept_result_cpuid_entry (cpu, subleaf_specific, +/* +* CPUID[0xD,0].EBX and CPUID[0xD,1].EBX report the XSAVE area +* size based on features currently enabled in XCR0/XSS. These +* values are dynamic and must not be overridden with static +* results from the QEMU CPU model. Setting ebx_mask to 0 lets +* the hypervisor supply EBX based on the guest's actual state. +*/ +if (entry->function ==0x0d && + (entry->index ==0 || entry->index ==1 )) { + ebx_mask =0 ; + } + + entry_ret =register_intercept_result_cpuid_entry (cpu, + subleaf_specific, always_override, + ebx_mask, entry);if ((entry_ret <0 ) && (ret ==0 )) { ret = entry_ret;
@@ -1663,6 +1681,7 @@ uint32_t mshv_get_supported_cpuid(uint32_t func, uint32_t idx, int reg)if (func ==0x01 && reg ==R_ECX ) { ret &= ~CPUID_EXT_VMX ; } +return ret; }
Signature · 1 line
2.34.1
Re: [PATCH v6 8/9] target/i386/mshv: use hv-provided [0xD,1+2].EBX
Quoted 26 lines · Magnus Kulke
We cannot statically set the responses for CPUID[0xD,{1,2}].EBX, b/c those are dynamic, dependent on which features the guest enables.
Hence we mask EBX when registering answers for those subleaves at the hypervisor, which will result in the hypervisor providing us answers, considering XCR0 and XSS.
The reported size now reflects the field masks properly (without the mask they were 576 and 10728, which is wrong):
$ cpuid -l 0xd -s 0 CPU 0: XSAVE features (0xd/0): XCR0 valid bit field mask = 0x00000000000600e7 ... bytes required by fields in XCR0 = 0x00002b00 (11008) bytes required by XSAVE/XRSTOR area = 0x00002b00 (11008)$ cpuid -l 0xd -s 1 CPU 0: XSAVE features (0xd/1): ... SAVE area size in bytes = 0x000029c0 (10688) IA32_XSS lower 32 bits valid bit field mask = 0x00001800 IA32_XSS upper 32 bits valid bit field mask = 0x00000000
Quoted 5 lines
Signed-off-by Magnus Kulke <[email protected]>--- target/i386/mshv/mshv-cpu.c | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-)
PATCH v6 9/9 accel/mshv: disable la57 (5lvl paging)
In reply to Magnus KulkeThis change disable la57 paging on the mshv hypervisor on both the mshv processor feature bitmap and mask the cpuid feature leaf to the guest.
Since the removal of hypervisor-assisted gva=>gpa translation in 1c85a4a3d7 we have seen MMIO errors in guests on la57-enabled hw. We will have to investigate and test this further.
--- accel/mshv/mshv-all.c | 7 +++++++ include/system/mshv_int.h | 2 ++ target/i386/mshv/mshv-cpu.c | 15 +++++++++++++++ 3 files changed, 24 insertions(+)
accel/mshv/mshv-all.c +7 -0
@@ -142,6 +142,8 @@ static int create_partition(int mshv_fd, int *vm_fd)int ret;uint64_t pt_flags, host_proc_features;union hv_partition_processor_xsave_features disabled_xsave_features; +union hv_partition_processor_features disabled_partition_features = {0 }; +struct mshv_create_partition_v2 args = {0 };QEMU_BUILD_BUG_ON (MSHV_NUM_CPU_FEATURES_BANKS !=2 );
@@ -177,6 +179,11 @@ static int create_partition(int mshv_fd, int *vm_fd) } args.pt_cpu_fbanks[1 ] = ~host_proc_features; +/* arch-specific features we disable regardless of host support */ +mshv_arch_disable_partition_proc_features (&disabled_partition_features); + args.pt_cpu_fbanks[0 ] |= disabled_partition_features.as_uint64[0 ]; + args.pt_cpu_fbanks[1 ] |= disabled_partition_features.as_uint64[1 ]; +/* populate args structure */ args.pt_flags = pt_flags; args.pt_isolation =MSHV_PT_ISOLATION_NONE ;
include/system/mshv_int.h +2 -0
@@ -94,6 +94,8 @@ void mshv_arch_init_vcpu(CPUState *cpu);void mshv_arch_destroy_vcpu (CPUState *cpu);void mshv_arch_amend_proc_features (union hv_partition_synthetic_processor_features *features); +void mshv_arch_disable_partition_proc_features ( +union hv_partition_processor_features *disabled_features);int mshv_arch_post_init_vm (int vm_fd);typedef struct mshv_root_hvcall mshv_root_hvcall ;
target/i386/mshv/mshv-cpu.c +15 -0
@@ -1129,6 +1129,12 @@ void mshv_arch_amend_proc_features( features->access_guest_idle_reg =1 ; } +void mshv_arch_disable_partition_proc_features ( +union hv_partition_processor_features *disabled_features) +{ + disabled_features->la57_support =1 ; +} +static int set_memory_info (const struct hyperv_message *msg,struct hv_x64_memory_intercept_message *info) {
@@ -1682,6 +1688,15 @@ uint32_t mshv_get_supported_cpuid(uint32_t func, uint32_t idx, int reg) ret &= ~CPUID_EXT_VMX ; } +if (func ==0x07 && idx ==0 && reg ==R_ECX ) { +/* +* LA57 (5-level paging) causes incorrect GVA=>GPA translations +* in the instruction decoder/emulator. Disable until page table +* walk in x86_mmu.c works w/ 5-level paging. +*/ + ret &= ~CPUID_7_0_ECX_LA57 ; + } +return ret; }
Signature · 1 line
2.34.1
Re: [PATCH v6 9/9] accel/mshv: disable la57 (5lvl paging)
Quoted 8 lines · Magnus Kulke
This change disable la57 paging on the mshv hypervisor on both the mshv processor feature bitmap and mask the cpuid feature leaf to the guest.
Since the removal of hypervisor-assisted gva=>gpa translation in
1c85a4a3d7we have seen MMIO errors in guests on la57-enabled hw. We will have to investigate and test this further.
Quoted 9 lines
Signed-off-by Magnus Kulke <[email protected]>Reviewed-by Wei Liu <[email protected]>--- accel/mshv/mshv-all.c | 7 +++++++ include/system/mshv_int.h | 2 ++ target/i386/mshv/mshv-cpu.c | 15 +++++++++++++++ 3 files changed, 24 insertions(+)