WHPX x86 updates for QEMU 11.1
cover WHPX x86 updates for QEMU 11.1
This rolls over my previous series posted earlier in this mailing list. ..and adds some more.
Git tree: https://github.com/mediouni-m/qemu whpx-i386-202604-4
Some highlights:
1
- user-mode x2APIC emulation (kernel-irqchip=off) for better performance when it has to be used.
- CPU model emulation on both Windows 10 and 11
- configurable behavior for unknown MSRs and adding a way to trap on GPFs raised by Hyper-V on MSR acccess
- when -M hyperv=off, report the hypervisor as VMware for guests to use either the VMware CPUID leaf or the vmport interface to get the TSC and APIC frequencies.
If the vmware CPUID frequency leaf is disabled, then KVM is reported.
- xsave save/restore support
- Pause the VM to be able to inspect state on a fatal fault instead of just exiting
- adding emulation of an oddball idle MSR used by Windows when kernel-irqchip=off.
- disable kernel-irqchip and Hyper-V enlightenments for isapc
- for Windows 10, change the default to an emulated x2APIC (kernel-irqchip=off). The recommended way to use the Hyper-V LAPIC is not to use -M kernel-irqchip=on, but -M pic=off.
And as the last commit, a documentation update.
Bug reports and patches are welcome.
However, due to reasons, I'll probably step aside from this all for a bit so don't expect immediate replies.
Magnus Kulke (1):
target/i386: add de/compaction to xsave_helper
Mohamed Mediouni (37):
target/i386: emulate: include name of unhandled instruction
whpx: i386: x2apic emulation
whpx: i386: wire up feature probing
whpx: i386: disable TbFlushHypercalls for emulated LAPIC
whpx: i386: enable x2apic by default for user-mode LAPIC
whpx: i386: reintroduce enlightenments for Windows 10
whpx: i386: introduce proper cpuid support
whpx: i386: kernel-irqchip=off fixes
whpx: i386: use WHvX64RegisterCr8 only when kernel-irqchip=off
whpx: i386: disable kernel-irqchip on Windows 10 when PIC enabled
whpx: i386: IO port fast path cleanup
whpx: i386: disable enlightenments and LAPIC for isapc
whpx: i386: interrupt priority support
hw/intc: apic: disallow APIC reads when disabled
whpx: i386: fix CPUID[1:EDX].APIC reporting
whpx: i386: set apicbase value only on success
whpx: i386: unknown MSR configurability
whpx: i386: enable GuestIdleReg enlightenment
whpx: i386: tighten APIC base validity check
whpx: i386: ignore vpassist when kernel-irqchip=off
target: i386: HLT type that ignores EFLAGS.IF
whpx: i386: add HV_X64_MSR_GUEST_IDLE when !kernel-irqchip
whpx: i386: one more CPUID
whpx: i386: some x2APIC awareness
whpx: i386: set WHvX64RegisterInitialApicId
whpx: i386: Pause VM on fatal exception to be able to inspect state target/i386: emulate: use exception_payload for fault address
whpx: i386: CPU features support for Windows 10 target/i386: make xsave_buf present unconditionally
whpx: xsave support
whpx: i386: set APIC ID only when APIC present
whpx: i386: update migration blocker message
whpx: i386: don't increment eip on MSR access raising GPF target/i386: emulate, hvf: rdmsr/wrmsr GPF handling
whpx: i386: add feature to intercept #GP MSR accesses
whpx: i386: intercept CPUID 0xD too
whpx: i386: documentation update
accel/whpx/whpx-common.c | 78 ++ docs/system/whpx.rst | 30 +- hw/intc/apic.c | 9 + include/system/whpx-common.h | 2 +- include/system/whpx-internal.h | 28 + target/arm/whpx/whpx-all.c | 1 + target/i386/cpu.c | 25 +- target/i386/cpu.h | 6 +- target/i386/emulate/x86_emu.c | 14 +- target/i386/emulate/x86_emu.h | 4 +- target/i386/emulate/x86_mmu.c | 3 +- target/i386/hvf/hvf.c | 9 +- target/i386/whpx/meson.build | 1 + target/i386/whpx/whpx-all.c | 1244 ++++++++++++++++++++++------ target/i386/whpx/whpx-apic.c | 83 +- target/i386/whpx/whpx-cpu-legacy.c | 171 ++++ target/i386/whpx/whpx-i386.h | 11 + target/i386/xsave_helper.c | 255 ++++++ 18 files changed, 1692 insertions(+), 282 deletions(-) create mode 100644 target/i386/whpx/whpx-cpu-legacy.c create mode 100644 target/i386/whpx/whpx-i386.h
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 1/38 target/i386: emulate: include name of unhandled instruction
Instead of just the command number, include the instruction name to make debugging easier.
--- target/i386/emulate/x86_emu.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
target/i386/emulate/x86_emu.c +2 -2
@@ -1399,8 +1399,8 @@ static void init_cmd_handler(void)bool exec_instruction (CPUX86State *env,struct x86_decode *ins) {if (!_cmd_handler[ins->cmd].handler) { -printf ("Unimplemented handler (" TARGET_FMT_lx") for %d (%x %x)\n" , - env->eip, +printf ("Unimplemented handler (" TARGET_FMT_lx") for %s - %d (%x %x)\n" , + env->eip,decode_cmd_to_string (ins->cmd), ins->cmd, ins->opcode[0 ], ins->opcode_len >1 ? ins->opcode[1 ] :0 ); env->eip += ins->len;
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 2/38 whpx: i386: x2apic emulation
In reply to Mohamed MediouniAdd x2apic emulation to WHPX for the kernel-irqchip=off case.
Unfortunately, it looks like there isn't a workaround available for proper behavior of PIC interrupts when kernel-irqchip=on for Windows 10. The OS is out of support outside of extended security updates so this will not be addressed.
The performance boost is quite visible for multicore guests.
--- target/i386/whpx/whpx-all.c | 134 +++++++++++++++++++++++++++++++++++- 1 file changed, 133 insertions(+), 1 deletion(-)
target/i386/whpx/whpx-all.c +133 -1
@@ -1082,6 +1082,8 @@ HRESULT whpx_set_exception_exit_bitmap(UINT64 exceptions)/* Register for MSR and CPUID exits */ memset (&prop,0 ,sizeof (WHV_PARTITION_PROPERTY )); prop.ExtendedVmExits.X64MsrExit =1 ; + prop.ExtendedVmExits.X64CpuidExit =1 ; +if (exceptions !=0 ) { prop.ExtendedVmExits.ExceptionExit =1 ; }
@@ -1898,6 +1900,18 @@ int whpx_vcpu_run(CPUState *cpu)WHV_REGISTER_NAME reg_names[3 ];UINT32 reg_count;bool is_known_msr =0 ; +uint64_t val; + +if (vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite) { + val = ((uint32_t )vcpu->exit_ctx.MsrAccess.Rax) | + ((uint64_t )(vcpu->exit_ctx.MsrAccess.Rdx) <<32 ); + }else { +/* +* Workaround for [-Werror=maybe-uninitialized] +* with GCC. Not needed with Clang. +*/ + val =0 ; + } reg_names[0 ] = WHvX64RegisterRip; reg_names[1 ] = WHvX64RegisterRax;
@@ -1911,7 +1925,47 @@ int whpx_vcpu_run(CPUState *cpu) && !vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite && !whpx_irqchip_in_kernel()) { is_known_msr =1 ; - reg_values[1 ].Reg32 = (uint32_t )X86_CPU (cpu)->env.apic_bus_freq; + val =X86_CPU (cpu)->env.apic_bus_freq; + } + +if (!whpx_irqchip_in_kernel () && + vcpu->exit_ctx.MsrAccess.MsrNumber ==MSR_IA32_APICBASE ) { + is_known_msr =1 ; +if (!vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite) { +/* Read path unreachable on Hyper-V */ +abort (); + }else { +WHV_REGISTER_VALUE reg = {.Reg64 = val}; +int msr_ret =cpu_set_apic_base (X86_CPU (cpu)->apic_state, val); +if (msr_ret <0 ) { +x86_emul_raise_exception (&X86_CPU (cpu)->env,EXCP0D_GPF ,0 ); + } +whpx_set_reg (cpu, WHvX64RegisterApicBase, reg); + } + } + +if (!whpx_irqchip_in_kernel () && + vcpu->exit_ctx.MsrAccess.MsrNumber >=MSR_APIC_START && + vcpu->exit_ctx.MsrAccess.MsrNumber <=MSR_APIC_END ) { +int index = vcpu->exit_ctx.MsrAccess.MsrNumber -MSR_APIC_START ; +int msr_ret; + is_known_msr =1 ; +if (!vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite) { +bql_lock (); + msr_ret =apic_msr_read (X86_CPU (cpu)->apic_state, index, &val); +bql_unlock (); + reg_values[1 ].Reg64 = val; +if (msr_ret <0 ) { +x86_emul_raise_exception (&X86_CPU (cpu)->env,EXCP0D_GPF ,0 ); + } + }else { +bql_lock (); + msr_ret =apic_msr_write (X86_CPU (cpu)->apic_state, index, val); +bql_unlock (); +if (msr_ret <0 ) { +x86_emul_raise_exception (&X86_CPU (cpu)->env,EXCP0D_GPF ,0 ); + } + } }/* * For all unsupported MSR access we:
@@ -1921,6 +1975,11 @@ int whpx_vcpu_run(CPUState *cpu) reg_count = vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite ?1 :3 ; +if (!vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite) { + reg_values[1 ].Reg32 = (uint32_t )val; + reg_values[2 ].Reg32 = (uint32_t )(val >>32 ); + } +if (!is_known_msr) {trace_whpx_unsupported_msr_access (vcpu->exit_ctx.MsrAccess.MsrNumber, vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite);
@@ -1939,6 +1998,47 @@ int whpx_vcpu_run(CPUState *cpu) ret =0 ;break ; } +case WHvRunVpExitReasonX64Cpuid: { +WHV_REGISTER_VALUE reg_values[5 ] = {0 }; +WHV_REGISTER_NAME reg_names[5 ]; +UINT32 reg_count =5 ; +X86CPU *x86_cpu =X86_CPU (cpu); +CPUX86State *env = &x86_cpu->env; + + reg_names[0 ] = WHvX64RegisterRip; + reg_names[1 ] = WHvX64RegisterRax; + reg_names[2 ] = WHvX64RegisterRcx; + reg_names[3 ] = WHvX64RegisterRdx; + reg_names[4 ] = WHvX64RegisterRbx; + + reg_values[0 ].Reg64 = + vcpu->exit_ctx.VpContext.Rip + + vcpu->exit_ctx.VpContext.InstructionLength; + + reg_values[1 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRax; + reg_values[2 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRcx; + reg_values[3 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRdx; + reg_values[4 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRbx; + +if (vcpu->exit_ctx.CpuidAccess.Rax ==1 ) { +if (cpu_has_x2apic_feature (env)) { + reg_values[2 ].Reg64 |=CPUID_EXT_X2APIC ; + } + } + + hr = whp_dispatch.WHvSetVirtualProcessorRegisters ( + whpx->partition, + cpu->cpu_index, + reg_names, reg_count, + reg_values); + +if (FAILED (hr)) { +error_report ("WHPX: Failed to set CpuidAccess state " +" registers, hr=%08lx" , hr); + } + ret =0 ; +break ; + }case WHvRunVpExitReasonException:whpx_get_registers (cpu,WHPX_LEVEL_FULL_STATE );
@@ -2136,6 +2236,7 @@ int whpx_accel_init(AccelState *as, MachineState *ms)WHV_PROCESSOR_FEATURES_BANKS processor_features;WHV_PROCESSOR_PERFMON_FEATURES perfmon_features;bool is_legacy_os = false; +UINT32 cpuidExitList[] = {1 }; whpx = &whpx_global;
@@ -2354,6 +2455,7 @@ int whpx_accel_init(AccelState *as, MachineState *ms)/* Register for MSR and CPUID exits */ memset (&prop,0 ,sizeof (WHV_PARTITION_PROPERTY )); prop.ExtendedVmExits.X64MsrExit =1 ; + prop.ExtendedVmExits.X64CpuidExit =1 ; hr = whp_dispatch.WHvSetPartitionProperty( whpx->partition,
@@ -2366,6 +2468,36 @@ int whpx_accel_init(AccelState *as, MachineState *ms) goto error; } +memset (&prop,0 ,sizeof (WHV_PARTITION_PROPERTY )); + prop.X64MsrExitBitmap.UnhandledMsrs =1 ; +if (!whpx_irqchip_in_kernel ()) { + prop.X64MsrExitBitmap.ApicBaseMsrWrite =1 ; + } + + hr = whp_dispatch.WHvSetPartitionProperty ( + whpx->partition, + WHvPartitionPropertyCodeX64MsrExitBitmap, + &prop, +sizeof (WHV_PARTITION_PROPERTY )); +if (FAILED (hr)) { +error_report ("WHPX: Failed to set MSR exit bitmap, hr=%08lx" , hr); + ret = -EINVAL ; + goto error; + } + + hr = whp_dispatch.WHvSetPartitionProperty ( + whpx->partition, + WHvPartitionPropertyCodeCpuidExitList, + cpuidExitList, +RTL_NUMBER_OF (cpuidExitList) *sizeof (UINT32 )); + +if (FAILED (hr)) { +error_report ("WHPX: Failed to set partition CpuidExitList hr=%08lx" , + hr); + ret = -EINVAL ; + goto error; + } +/* * We do not want to intercept any exceptions from the guest, * until we actually start debugging with gdb.
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 3/38 whpx: i386: wire up feature probing
In reply to Mohamed MediouniWindows 10 doesn't have the API for this, so using this only for Windows 11.
--- include/system/whpx-internal.h | 9 ++++ target/i386/cpu.c | 25 ++++++++++++ target/i386/whpx/whpx-all.c | 75 ++++++++++++++++++++++++++++++++-- target/i386/whpx/whpx-i386.h | 4 ++ 4 files changed, 109 insertions(+), 4 deletions(-) create mode 100644 target/i386/whpx/whpx-i386.h
include/system/whpx-internal.h +9 -0
@@ -73,6 +73,14 @@ void whpx_apic_get(APICCommonState *s); X(HRESULT, WHvGetVirtualProcessorRegisters, (WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, const WHV_REGISTER_NAME* RegisterNames, UINT32 RegisterCount, WHV_REGISTER_VALUE* RegisterValues)) \ X(HRESULT, WHvSetVirtualProcessorRegisters, (WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, const WHV_REGISTER_NAME* RegisterNames, UINT32 RegisterCount, const WHV_REGISTER_VALUE* RegisterValues)) \ +#ifdef __x86_64__ +#define LIST_WINHVPLATFORM_FUNCTIONS_SUPPLEMENTAL_ARCH (X ) \ + X(HRESULT, WHvGetVirtualProcessorCpuidOutput, \ + (WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, UINT32 Eax, \ + UINT32 Ecx, WHV_CPUID_OUTPUT *CpuidOutput)) +#else +#define LIST_WINHVPLATFORM_FUNCTIONS_SUPPLEMENTAL_ARCH (X ) +#endif /* * These are supplemental functions that may not be present * on all versions and are not critical for basic functionality.
@@ -89,6 +97,7 @@ void whpx_apic_get(APICCommonState *s); UINT32 StateSize)) \ X(HRESULT, WHvResetPartition, \ (WHV_PARTITION_HANDLE Partition)) \ + LIST_WINHVPLATFORM_FUNCTIONS_SUPPLEMENTAL_ARCH(X) #define WHP_DEFINE_TYPE(return_type, function_name, signature) \ typedef return_type (WINAPI *function_name ## _t) signature;
target/i386/cpu.c +25 -0
@@ -26,6 +26,8 @@#include "tcg/helper-tcg.h" #include "exec/translation-block.h" #include "system/hvf.h" +#include "system/whpx.h" +#include "whpx/whpx-i386.h" #include "hvf/hvf-i386.h" #include "kvm/kvm_i386.h" #include "kvm/tdx.h"
@@ -8087,6 +8089,17 @@ 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 (whpx_enabled ()) { +if (wi->type !=CPUID_FEATURE_WORD ) { +return 0 ; + } +if (whpx_is_legacy_os ()) { + r = wi->tcg_features; + }else { + r =whpx_get_supported_cpuid (wi->cpuid.eax, + wi->cpuid.ecx, + wi->cpuid.reg); + } }else if (tcg_enabled () ||qtest_enabled ()) { r = wi->tcg_features; }else {
@@ -8168,6 +8181,18 @@ static void x86_cpu_get_supported_cpuid(uint32_t func, uint32_t index, *ebx =hvf_get_supported_cpuid (func, index,R_EBX ); *ecx =hvf_get_supported_cpuid (func, index,R_ECX ); *edx =hvf_get_supported_cpuid (func, index,R_EDX ); + }else if (whpx_enabled ()) { +if (whpx_is_legacy_os ()) { + *eax =0 ; + *ebx =0 ; + *ecx =0 ; + *edx =0 ; + }else { + *eax =whpx_get_supported_cpuid (func, index,R_EAX ); + *ebx =whpx_get_supported_cpuid (func, index,R_EBX ); + *ecx =whpx_get_supported_cpuid (func, index,R_ECX ); + *edx =whpx_get_supported_cpuid (func, index,R_EDX ); + } }else { *eax =0 ; *ebx =0 ;
target/i386/whpx/whpx-all.c +71 -4
117 lines not on this page · raw message
target/i386/whpx/whpx-i386.h new file +4 -0
@@ -0,0 +1,4 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +uint32_t whpx_get_supported_cpuid (uint32_t func,uint32_t idx,int reg); +bool whpx_is_legacy_os (void );
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 4/38 whpx: i386: disable TbFlushHypercalls for emulated LAPIC
In reply to Mohamed MediouniAccessHypercallRegs was present twice so clean that up.
Remove TbFlushHypercalls (and its extended Gva range sub-feature) from the user-mode LAPIC case as it behaves oddly there.
--- target/i386/whpx/whpx-all.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
target/i386/whpx/whpx-all.c +6 -3
@@ -2489,10 +2489,7 @@ int whpx_accel_init(AccelState *as, MachineState *ms) synthetic_features.Bank0.AccessPartitionReferenceTsc =1 ; synthetic_features.Bank0.AccessHypercallRegs =1 ; synthetic_features.Bank0.AccessFrequencyRegs =1 ; - synthetic_features.Bank0.EnableExtendedGvaRangesForFlushVirtualAddressList =1 ; synthetic_features.Bank0.AccessVpIndex =1 ; - synthetic_features.Bank0.AccessHypercallRegs =1 ; - synthetic_features.Bank0.TbFlushHypercalls =1 ;if (whpx_irqchip_in_kernel ()) { synthetic_features.Bank0.AccessSynicRegs =1 ;
@@ -2500,6 +2497,12 @@ int whpx_accel_init(AccelState *as, MachineState *ms) synthetic_features.Bank0.AccessIntrCtrlRegs =1 ; synthetic_features.Bank0.SyntheticClusterIpi =1 ; synthetic_features.Bank0.DirectSyntheticTimers =1 ; +/* +* These technically work without the Hyper-V LAPIC +* but behave oddly for multi-core VMs. +*/ + synthetic_features.Bank0.TbFlushHypercalls =1 ; + synthetic_features.Bank0.EnableExtendedGvaRangesForFlushVirtualAddressList =1 ; }if (is_modern_os && whpx->hyperv_enlightenments_allowed) {
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 5/38 whpx: i386: enable x2apic by default for user-mode LAPIC
In reply to Mohamed Mediouni--- target/i386/whpx/whpx-all.c | 7 +++++++ 1 file changed, 7 insertions(+)
target/i386/whpx/whpx-all.c +7 -0
@@ -2281,11 +2281,18 @@ error:return ret; } +static PropValue whpx_default_props[] = { + {"x2apic" ,"on" }, + {NULL ,NULL }, +}; + +void whpx_cpu_instance_init (CPUState *cs) {X86CPU *cpu =X86_CPU (cs);host_cpu_instance_init (cpu); +x86_cpu_apply_props (cpu, whpx_default_props); }/*
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 6/38 whpx: i386: reintroduce enlightenments for Windows 10
In reply to Mohamed MediouniWas removed in 2c08624 but it's still useful for Windows 10 so reintroduce it there.
And this time, actually make it work by reporting the hypervisor bit in CPUID.
Pretend to be vmware to be able to use vmport's functionality.
If the vmware frequency leaf is disabled, pretend to be KVM, with the only capability reported being X2APIC support.
--- accel/whpx/whpx-common.c | 2 ++ include/system/whpx-internal.h | 1 + target/arm/whpx/whpx-all.c | 1 + target/i386/whpx/whpx-all.c | 63 +++++++++++++++++++++++++++++----- 4 files changed, 58 insertions(+), 9 deletions(-)
accel/whpx/whpx-common.c +2 -0
@@ -550,6 +550,8 @@ static void whpx_accel_instance_init(Object *obj) whpx->hyperv_enlightenments_allowed = true; whpx->hyperv_enlightenments_required = false; +/* Value determined at whpx_accel_init */ + whpx->hyperv_enlightenments_enabled = false; }static const TypeInfo whpx_accel_type = {
include/system/whpx-internal.h +1 -0
@@ -45,6 +45,7 @@ struct whpx_state {bool hyperv_enlightenments_allowed;bool hyperv_enlightenments_required; +bool hyperv_enlightenments_enabled; };
target/arm/whpx/whpx-all.c +1 -0
@@ -968,6 +968,7 @@ int whpx_accel_init(AccelState *as, MachineState *ms)* as they're not needed for performance. */ if (whpx->hyperv_enlightenments_required) { + whpx->hyperv_enlightenments_enabled = true; hr = whp_dispatch.WHvSetPartitionProperty( whpx->partition, WHvPartitionPropertyCodeSyntheticProcessorFeaturesBanks,
target/i386/whpx/whpx-all.c +54 -9
87 lines not on this page · raw message
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 7/38 whpx: i386: introduce proper cpuid support
In reply to Mohamed MediouniUnlike the implementation in QEMU 10.2, this one works.
It's not optimal though as it doesn't use the Hyper-V support for this.
--- target/i386/whpx/whpx-all.c | 123 ++++++++++++++++++++++++++++++++++-- 1 file changed, 119 insertions(+), 4 deletions(-)
target/i386/whpx/whpx-all.c +119 -4
@@ -2071,6 +2071,7 @@ int whpx_vcpu_run(CPUState *cpu)WHV_REGISTER_NAME reg_names[5 ];UINT32 reg_count =5 ;X86CPU *x86_cpu =X86_CPU (cpu); +X86CPUClass *xcc =X86_CPU_GET_CLASS (cpu);CPUX86State *env = &x86_cpu->env; reg_names[0 ] = WHvX64RegisterRip;
@@ -2083,7 +2084,15 @@ int whpx_vcpu_run(CPUState *cpu) vcpu->exit_ctx.VpContext.Rip + vcpu->exit_ctx.VpContext.InstructionLength; -if (whpx_is_legacy_os ()) { +/* +* On Windows 10 we can't query features from +* the Hyper-V interface. +* +* On Windows 11, if using xcc->max_features +* just pass through what the hypervisor +* provides without any QEMU filtering. +*/ +if (whpx_is_legacy_os () || xcc->max_features) { reg_values[1 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRax; reg_values[2 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRcx; reg_values[3 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRdx;
@@ -2135,6 +2144,60 @@ int whpx_vcpu_run(CPUState *cpu) }break ; } + }else { +switch (vcpu->exit_ctx.CpuidAccess.Rax) { +case 0x40000000 : +case 0x40000001 : +case 0x40000010 : + reg_values[1 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRax; + reg_values[2 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRcx; + reg_values[3 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRdx; + reg_values[4 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRbx; +break ; + } + } + +if (vcpu->exit_ctx.CpuidAccess.Rax ==0x1 ) { +if (cpu_has_x2apic_feature (env)) { + reg_values[2 ].Reg64 |=CPUID_EXT_X2APIC ; + }else { + reg_values[2 ].Reg32 &= ~CPUID_EXT_X2APIC ; + } + } + +/* Dynamic depending on XCR0 and XSS, so query DefaultResult */ +if (vcpu->exit_ctx.CpuidAccess.Rax ==0x07 + && vcpu->exit_ctx.CpuidAccess.Rcx ==0 ) { +if (vcpu->exit_ctx.CpuidAccess.DefaultResultRdx + &CPUID_7_0_EDX_CET_IBT ) { + reg_values[3 ].Reg32 |=CPUID_7_0_EDX_CET_IBT ; + }else { + reg_values[3 ].Reg32 &= ~CPUID_7_0_EDX_CET_IBT ; + } + +if (vcpu->exit_ctx.CpuidAccess.DefaultResultRcx + &CPUID_7_0_ECX_CET_SHSTK ) { + reg_values[2 ].Reg32 |=CPUID_7_0_ECX_CET_SHSTK ; + }else { + reg_values[2 ].Reg32 &= ~CPUID_7_0_ECX_CET_SHSTK ; + } + +if (vcpu->exit_ctx.CpuidAccess.DefaultResultRcx + &CPUID_7_0_ECX_OSPKE ) { + reg_values[2 ].Reg32 |=CPUID_7_0_ECX_OSPKE ; + }else { + reg_values[2 ].Reg32 &= ~CPUID_7_0_ECX_OSPKE ; + } + } + +/* OSXSAVE is dynamic. Do this instead of syncing CR4 */ +if (vcpu->exit_ctx.CpuidAccess.Rax ==1 ) { +if (vcpu->exit_ctx.CpuidAccess.DefaultResultRcx + &CPUID_EXT_OSXSAVE ) { + reg_values[2 ].Reg32 |=CPUID_EXT_OSXSAVE ; + }else { + reg_values[2 ].Reg32 &= ~CPUID_EXT_OSXSAVE ; + } } hr = whp_dispatch.WHvSetVirtualProcessorRegisters(
@@ -2324,6 +2387,45 @@ error:return ret; } +static void whpx_cpu_xsave_init (void ) +{ +static bool first = true; +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) { +int sz =whpx_get_supported_cpuid (0xd , i,R_EAX ); +if (sz !=0 ) { +assert (esa->size == sz); + esa->offset =whpx_get_supported_cpuid (0xd , i,R_EBX ); + } + } + } +} + +static void whpx_cpu_max_instance_init (X86CPU *cpu) +{ +CPUX86State *env = &cpu->env; + + env->cpuid_min_level = +whpx_get_supported_cpuid (0x0 ,0 ,R_EAX ); + env->cpuid_min_xlevel = +whpx_get_supported_cpuid (0x80000000 ,0 ,R_EAX ); + env->cpuid_min_xlevel2 = +whpx_get_supported_cpuid (0xC0000000 ,0 ,R_EAX ); +} +static PropValue whpx_default_props[] = { {"x2apic" ,"on" }, {NULL ,NULL },
@@ -2333,9 +2435,18 @@ static PropValue whpx_default_props[] = {void whpx_cpu_instance_init (CPUState *cs) {X86CPU *cpu =X86_CPU (cs); +X86CPUClass *xcc =X86_CPU_GET_CLASS (cpu);host_cpu_instance_init (cpu);x86_cpu_apply_props (cpu, whpx_default_props); + +if (!whpx_is_legacy_os () && xcc->max_features) { +whpx_cpu_max_instance_init (cpu); + } + +if (!whpx_is_legacy_os ()) { +whpx_cpu_xsave_init (); + } }/*
@@ -2353,8 +2464,12 @@ int whpx_accel_init(AccelState *as, MachineState *ms)WHV_CAPABILITY_FEATURES features = {0 };WHV_PROCESSOR_FEATURES_BANKS processor_features;WHV_PROCESSOR_PERFMON_FEATURES perfmon_features; -UINT32 cpuidExitList[] = {1 }; -UINT32 cpuidExitList_nohyperv[] = {1 ,0x40000000 ,0x40000001 ,0x40000010 }; + +UINT32 cpuidExitList[] = {0x0 ,0x1 ,0x6 ,0x7 ,0x14 ,0x24 ,0x29 ,0x1E , +0x40000000 ,0x40000001 ,0x40000010 ,0x80000000 ,0x80000001 , +0x80000002 ,0x80000003 ,0x80000004 ,0x80000007 ,0x80000008 , +0x8000000A ,0x80000021 ,0x80000022 ,0xC0000000 ,0xC0000001 }; +UINT32 cpuidExitList_legacy_os[] = {1 ,0x40000000 ,0x40000001 ,0x40000010 }; whpx = &whpx_global;
@@ -2610,7 +2725,7 @@ int whpx_accel_init(AccelState *as, MachineState *ms) hr = whp_dispatch.WHvSetPartitionProperty ( whpx->partition, WHvPartitionPropertyCodeCpuidExitList, - whpx->hyperv_enlightenments_enabled ? cpuidExitList : cpuidExitList_nohyperv, + !whpx_is_legacy_os () ? cpuidExitList : cpuidExitList_legacy_os,RTL_NUMBER_OF (cpuidExitList) *sizeof (UINT32 ));if (FAILED (hr)) {
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 8/38 whpx: i386: kernel-irqchip=off fixes
In reply to Mohamed MediouniThis was really... quite broken. After fixing this, Windows boots with kernel-irqchip=off.
--- include/system/whpx-common.h | 1 + target/i386/whpx/whpx-all.c | 43 +++++------------------------------- 2 files changed, 7 insertions(+), 37 deletions(-)
include/system/whpx-common.h +1 -0
@@ -4,6 +4,7 @@struct AccelCPUState {bool window_registered; +int window_priority;bool interruptable;bool ready_for_pic_interrupt;uint64_t tpr;
target/i386/whpx/whpx-all.c +6 -37
85 lines not on this page · raw message
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 9/38 whpx: i386: use WHvX64RegisterCr8 only when kernel-irqchip=off
In reply to Mohamed MediouniWhen kernel-irqchip=on, manage TPR as part of the APIC state instead entirely.
This fixes some failure to set state errors.
--- target/i386/whpx/whpx-all.c | 37 ++++++++++++++++++++++--------------- 1 file changed, 22 insertions(+), 15 deletions(-)
target/i386/whpx/whpx-all.c +22 -15
@@ -95,7 +95,6 @@ static const WHV_REGISTER_NAME whpx_register_names[] = { WHvX64RegisterCr2, WHvX64RegisterCr3, WHvX64RegisterCr4, - WHvX64RegisterCr8,/* X64 Debug Registers */ /*
@@ -459,8 +458,11 @@ void whpx_set_registers(CPUState *cpu, WHPXStateLevel level) vcxt.values[idx++].Reg64 = env->cr[3 ];assert (whpx_register_names[idx] == WHvX64RegisterCr4); vcxt.values[idx++].Reg64 = env->cr[4 ]; -assert (whpx_register_names[idx] == WHvX64RegisterCr8); - vcxt.values[idx++].Reg64 = vcpu->tpr; +/* For kernel-irqchip=on, TPR is managed as part of APIC state */ +if (!whpx_irqchip_in_kernel ()) { +WHV_REGISTER_VALUE cr8 = {.Reg64 = vcpu->tpr}; +whpx_set_reg (cpu, WHvX64RegisterCr8, cr8); + }/* 8 Debug Registers - Skipped */
@@ -716,11 +718,14 @@ void whpx_get_registers(CPUState *cpu, WHPXStateLevel level) env->cr[3 ] = vcxt.values[idx++].Reg64;assert (whpx_register_names[idx] == WHvX64RegisterCr4); env->cr[4 ] = vcxt.values[idx++].Reg64; -assert (whpx_register_names[idx] == WHvX64RegisterCr8); - tpr = vcxt.values[idx++].Reg64; -if (tpr != vcpu->tpr) { - vcpu->tpr = tpr; -cpu_set_apic_tpr (x86_cpu->apic_state, tpr); + +/* For kernel-irqchip=on, TPR is managed as part of APIC state */ +if (!whpx_irqchip_in_kernel ()) { + tpr = vcpu->exit_ctx.VpContext.Cr8; +if (tpr != vcpu->tpr) { + vcpu->tpr = tpr; +cpu_set_apic_tpr (x86_cpu->apic_state, tpr); + } }/* 8 Debug Registers - Skipped */
@@ -1660,7 +1665,7 @@ static void whpx_vcpu_pre_run(CPUState *cpu)/* Sync the TPR to the CR8 if was modified during the intercept */ tpr =cpu_get_apic_tpr (x86_cpu->apic_state); -if (tpr != vcpu->tpr) { +if (!whpx_irqchip_in_kernel () && tpr != vcpu->tpr) { vcpu->tpr = tpr; reg_values[reg_count].Reg64 = tpr;qatomic_set (&cpu->exit_request, true);
@@ -1702,12 +1707,14 @@ static void whpx_vcpu_post_run(CPUState *cpu) env->eflags = vcpu->exit_ctx.VpContext.Rflags; -uint64_t tpr = vcpu->exit_ctx.VpContext.Cr8; -if (vcpu->tpr != tpr) { - vcpu->tpr = tpr; -bql_lock (); -cpu_set_apic_tpr (x86_cpu->apic_state, vcpu->tpr); -bql_unlock (); +if (!whpx_irqchip_in_kernel ()) { +uint64_t tpr = vcpu->exit_ctx.VpContext.Cr8; +if (vcpu->tpr != tpr) { + vcpu->tpr = tpr; +bql_lock (); +cpu_set_apic_tpr (x86_cpu->apic_state, vcpu->tpr); +bql_unlock (); + } } vcpu->interruption_pending =
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 10/38 whpx: i386: disable kernel-irqchip on Windows 10 when PIC enabled
In reply to Mohamed MediouniMove WHvCapabilityCodeProcessorPerfmonFeatures queries as that's how we distinguish if on a legacy OS.
Now that Windows guests are booting, disable kernel-irqchip=on by default for Windows 10 when the PIC is enabled.
--- target/i386/whpx/whpx-all.c | 69 +++++++++++++++++++++---------------- 1 file changed, 39 insertions(+), 30 deletions(-)
target/i386/whpx/whpx-all.c +39 -30
@@ -2447,6 +2447,13 @@ int whpx_accel_init(AccelState *as, MachineState *ms) 0x8000000A, 0x80000021, 0x80000022, 0xC0000000, 0xC0000001};UINT32 cpuidExitList_legacy_os[] = {1 ,0x40000000 ,0x40000001 ,0x40000010 }; +X86MachineState *x86ms =X86_MACHINE (ms); +bool pic_enabled = false; + +if (x86ms->pic ==ON_OFF_AUTO_ON || x86ms->pic ==ON_OFF_AUTO_AUTO ) { + pic_enabled = true; + } + whpx = &whpx_global;if (!init_whp_dispatch ()) {
@@ -2518,6 +2525,35 @@ int whpx_accel_init(AccelState *as, MachineState *ms) goto error; } +/* Enable supported performance monitoring capabilities */ + hr = whp_dispatch.WHvGetCapability ( + WHvCapabilityCodeProcessorPerfmonFeatures, &perfmon_features, +sizeof (WHV_PROCESSOR_PERFMON_FEATURES ), &whpx_cap_size); +/* +* Relying on this is a crutch to maintain Windows 10 support. +* +* WHvCapabilityCodeProcessorPerfmonFeatures and +* WHvPartitionPropertyCodeSyntheticProcessorFeaturesBanks +* are implemented starting from Windows Server 2022 (build 20348). +*/ +if (FAILED (hr)) { +warn_report ("WHPX: Failed to get performance " +"monitoring features, hr=%08lx" , hr); + is_modern_os = false; + }else { + hr = whp_dispatch.WHvSetPartitionProperty ( + whpx->partition, + WHvPartitionPropertyCodeProcessorPerfmonFeatures, + &perfmon_features, +sizeof (WHV_PROCESSOR_PERFMON_FEATURES )); +if (FAILED (hr)) { +error_report ("WHPX: Failed to set performance " +"monitoring features, hr=%08lx" , hr); + ret = -EINVAL ; + goto error; + } + } +/* * Error out if WHP doesn't support apic emulation and user is requiring * it.
@@ -2530,8 +2566,9 @@ int whpx_accel_init(AccelState *as, MachineState *ms) goto error; } -if (whpx->kernel_irqchip_allowed && features.LocalApicEmulation && - whp_dispatch.WHvSetVirtualProcessorInterruptControllerState2) { +if (whpx->kernel_irqchip_allowed && !(whpx_is_legacy_os () && pic_enabled + && !whpx->kernel_irqchip_required) && features.LocalApicEmulation + && whp_dispatch.WHvSetVirtualProcessorInterruptControllerState2) {WHV_X64_LOCAL_APIC_EMULATION_MODE mode = WHvX64LocalApicEmulationModeX2Apic; hr = whp_dispatch.WHvSetPartitionProperty(
@@ -2590,34 +2627,6 @@ int whpx_accel_init(AccelState *as, MachineState *ms) goto error; } -/* Enable supported performance monitoring capabilities */ - hr = whp_dispatch.WHvGetCapability ( - WHvCapabilityCodeProcessorPerfmonFeatures, &perfmon_features, -sizeof (WHV_PROCESSOR_PERFMON_FEATURES ), &whpx_cap_size); -/* -* Relying on this is a crutch to maintain Windows 10 support. -* -* WHvCapabilityCodeProcessorPerfmonFeatures and -* WHvPartitionPropertyCodeSyntheticProcessorFeaturesBanks -* are implemented starting from Windows Server 2022 (build 20348). -*/ -if (FAILED (hr)) { -warn_report ("WHPX: Failed to get performance " -"monitoring features, hr=%08lx" , hr); - is_modern_os = false; - }else { - hr = whp_dispatch.WHvSetPartitionProperty ( - whpx->partition, - WHvPartitionPropertyCodeProcessorPerfmonFeatures, - &perfmon_features, -sizeof (WHV_PROCESSOR_PERFMON_FEATURES )); -if (FAILED (hr)) { -error_report ("WHPX: Failed to set performance " -"monitoring features, hr=%08lx" , hr); - ret = -EINVAL ; - goto error; - } - }/* Enable synthetic processor features */ WHV_SYNTHETIC_PROCESSOR_FEATURES_BANKS synthetic_features;
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 11/38 whpx: i386: IO port fast path cleanup
In reply to Mohamed Mediounivmport calls synchronise_state within an I/O port read. Support that properly.
What was there before worked because of a side effect of whpx_get_reg synchronising context if cpu->vcpu_dirty.
Remove that whpx_get_reg call in whpx_bump_rip too as it's no longer needed now.
--- target/i386/whpx/whpx-all.c | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-)
target/i386/whpx/whpx-all.c +13 -4
@@ -862,7 +862,6 @@ static void handle_io(CPUState *env, uint16_t port, void *buffer,static void whpx_bump_rip (CPUState *cpu,WHV_RUN_VP_EXIT_CONTEXT *exit_ctx) {WHV_REGISTER_VALUE reg; -whpx_get_reg (cpu, WHvX64RegisterRip, ®); reg.Reg64 = exit_ctx->VpContext.Rip + exit_ctx->VpContext.InstructionLength;whpx_set_reg (cpu, WHvX64RegisterRip, reg); }
@@ -890,13 +889,23 @@ static int whpx_handle_portio(CPUState *cpu, }else { reg.Reg64 = (uint64_t )val; } -whpx_bump_rip (cpu, exit_ctx); -whpx_set_reg (cpu, WHvX64RegisterRax, reg); +/* vmport calls cpu_synchronize_state on an I/O port read */ +if (!cpu->vcpu_dirty) { +whpx_bump_rip (cpu, exit_ctx); +whpx_set_reg (cpu, WHvX64RegisterRax, reg); + }else { + env->eip = exit_ctx->VpContext.Rip + exit_ctx->VpContext.InstructionLength; + env->regs[R_EAX ] = reg.Reg64; + }return 0 ; }else if (!ctx->AccessInfo.StringOp && ctx->AccessInfo.IsWrite) {RAX (env) = ctx->Rax;handle_io (cpu, ctx->PortNumber, &RAX (env),1 , ctx->AccessInfo.AccessSize,1 ); -whpx_bump_rip (cpu, exit_ctx); +if (!cpu->vcpu_dirty) { +whpx_bump_rip (cpu, exit_ctx); + }else { + env->eip = exit_ctx->VpContext.Rip + exit_ctx->VpContext.InstructionLength; + }return 0 ; }
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 12/38 whpx: i386: disable enlightenments and LAPIC for isapc
In reply to Mohamed MediouniThe isapc machine doesn't have an APIC. And Hyper-V enlightenments don't sound too useful to have there so disable those.
--- target/i386/whpx/whpx-all.c | 8 ++++++++ 1 file changed, 8 insertions(+)
target/i386/whpx/whpx-all.c +8 -0
@@ -2470,6 +2470,14 @@ int whpx_accel_init(AccelState *as, MachineState *ms) goto error; } +/* for isapc, disable Hyper-V enlightenments and LAPIC */ +if (!strcmp (MACHINE_GET_CLASS (ms)->name,"isapc" )) { + whpx->kernel_irqchip_allowed = false; + whpx->kernel_irqchip_required = false; + whpx->hyperv_enlightenments_allowed = false; + whpx->hyperv_enlightenments_required = false; + } + whpx->mem_quota = ms->ram_size; hr = whp_dispatch.WHvGetCapability(
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 13/38 whpx: i386: interrupt priority support
In reply to Mohamed MediouniImplement APIC IRR interrupt priorities.
Even with kernel-irqchip=off, Hyper-V is aware of interrupt priorities and implements CR8/TPR, with the InterruptPriority field being followed.
--- target/i386/whpx/whpx-all.c | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-)
target/i386/whpx/whpx-all.c +20 -4
@@ -1588,6 +1588,7 @@ static void whpx_vcpu_pre_run(CPUState *cpu)UINT32 reg_count =0 ;WHV_REGISTER_VALUE reg_values[3 ];WHV_REGISTER_NAME reg_names[3 ]; +int irr =apic_get_highest_priority_irr (x86_cpu->apic_state);memset (&new_int,0 ,sizeof (new_int));memset (reg_values,0 ,sizeof (reg_values));
@@ -1623,10 +1624,20 @@ static void whpx_vcpu_pre_run(CPUState *cpu) } } +if (irr ==-1 ) { +if (isa_pic !=NULL &&pic_get_output (isa_pic)) { +/* In case it's a PIC interrupt */ + irr =0 ; + }else if (cpu_test_interrupt (cpu,CPU_INTERRUPT_HARD )) { +abort (); + } + } +/* Get pending hard interruption or replay one that was overwritten */ if (!whpx_irqchip_in_kernel ()) {if (!vcpu->interruption_pending && - vcpu->interruptable && (env->eflags &IF_MASK )) { + vcpu->interruptable && (env->eflags &IF_MASK ) + && (vcpu->tpr < irr || irr ==0 )) {assert (!new_int.InterruptionPending);if (cpu_test_interrupt (cpu,CPU_INTERRUPT_HARD )) {cpu_reset_interrupt (cpu,CPU_INTERRUPT_HARD );
@@ -1683,13 +1694,17 @@ static void whpx_vcpu_pre_run(CPUState *cpu) }/* Update the state of the interrupt delivery notification */ -if (!vcpu->window_registered && +if ((!vcpu->window_registered || + (vcpu->window_priority < irr && vcpu->window_priority !=0 ) || + (irr ==0 && vcpu->window_priority !=0 )) &&cpu_test_interrupt (cpu,CPU_INTERRUPT_HARD )) { reg_values[reg_count].DeliverabilityNotifications = (WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER ) { - .InterruptNotification =1 + .InterruptNotification =1 , + .InterruptPriority = irr >>4 }; vcpu->window_registered =1 ; + vcpu->window_priority = irr; reg_names[reg_count] = WHvX64RegisterDeliverabilityNotifications; reg_count +=1 ; }
@@ -1703,7 +1718,7 @@ static void whpx_vcpu_pre_run(CPUState *cpu) reg_names, reg_count, reg_values);if (FAILED (hr)) {error_report ("WHPX: Failed to set interrupt state registers," -" hr=%08lx" , hr); +" hr=%08lx, InterruptPriority=%i" , hr, irr >>4 ); } } }
@@ -1919,6 +1934,7 @@ int whpx_vcpu_run(CPUState *cpu)case WHvRunVpExitReasonX64InterruptWindow: vcpu->ready_for_pic_interrupt =1 ; vcpu->window_registered =0 ; + vcpu->window_priority =0 ; ret =0 ;break ;
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 14/38 hw/intc: apic: disallow APIC reads when disabled
In reply to Mohamed Mediouni!APICBASE_ENABLE + attempting to read xAPIC registers is not an allowed combination.
And neither is x2APIC enabled + attempting to read xAPIC registers
--- hw/intc/apic.c | 9 +++++++++ 1 file changed, 9 insertions(+)
hw/intc/apic.c +9 -0
@@ -875,6 +875,15 @@ static uint64_t apic_mem_read(void *opaque, hwaddr addr, unsigned size)return -1 ; } +/* if the xAPIC is disabled, return early. */ +if (!(s->apicbase &MSR_IA32_APICBASE_ENABLE )) { +return 0xffffffff ; + } + +if (is_x2apic_mode (s)) { +return 0xffffffff ; + } + index = (addr >>4 ) &0xff ;apic_register_read (s, index, &val);
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 15/38 whpx: i386: fix CPUID[1:EDX].APIC reporting
In reply to Mohamed MediouniHyper-V always has CPUID[1:EDX].APIC set, even when the APIC isn't enabled yet.
Work around this by also using the APICBASE trap for kernel-irqchip=on.
--- include/system/whpx-common.h | 1 - target/i386/whpx/whpx-all.c | 34 ++++++++--------- target/i386/whpx/whpx-apic.c | 71 ++++++++++++++++++++++++++++++++++-- 3 files changed, 84 insertions(+), 22 deletions(-)
include/system/whpx-common.h +0 -1
@@ -8,7 +8,6 @@ struct AccelCPUState {bool interruptable;bool ready_for_pic_interrupt;uint64_t tpr; -uint64_t apic_base;bool interruption_pending;/* Must be the last field as it may have a tail */ WHV_RUN_VP_EXIT_CONTEXT exit_ctx;
target/i386/whpx/whpx-all.c +16 -18
@@ -139,7 +139,6 @@ static const WHV_REGISTER_NAME whpx_register_names[] = {#ifdef TARGET_X86_64 WHvX64RegisterKernelGsBase, #endif - WHvX64RegisterApicBase,/* WHvX64RegisterPat, */ WHvX64RegisterSysenterCs, WHvX64RegisterSysenterEip,
@@ -401,7 +400,6 @@ void whpx_set_registers(CPUState *cpu, WHPXStateLevel level) r86 = !(env->cr[0 ] &CR0_PE_MASK ); vcpu->tpr =cpu_get_apic_tpr (x86_cpu->apic_state); - vcpu->apic_base =cpu_get_apic_base (x86_cpu->apic_state); idx =0 ;
@@ -519,9 +517,6 @@ void whpx_set_registers(CPUState *cpu, WHPXStateLevel level) vcxt.values[idx++].Reg64 = env->kernelgsbase;#endif -assert (whpx_register_names[idx] == WHvX64RegisterApicBase); - vcxt.values[idx++].Reg64 = vcpu->apic_base; -/* WHvX64RegisterPat - Skipped */ assert (whpx_register_names[idx] == WHvX64RegisterSysenterCs);
@@ -556,6 +551,12 @@ void whpx_set_registers(CPUState *cpu, WHPXStateLevel level)error_report ("WHPX: Failed to set virtual processor context, hr=%08lx" , hr); } + +if (level >=WHPX_LEVEL_FULL_STATE ) { +WHV_REGISTER_VALUE apic_base = {}; + apic_base.Reg64 =cpu_get_apic_base (X86_CPU (cpu)->apic_state); +whpx_set_reg (cpu, WHvX64RegisterApicBase, apic_base); + } }static int whpx_get_tsc (CPUState *cpu)
@@ -647,7 +648,7 @@ void whpx_get_registers(CPUState *cpu, WHPXStateLevel level)X86CPU *x86_cpu =X86_CPU (cpu);CPUX86State *env = &x86_cpu->env;struct whpx_register_set vcxt; -uint64_t tpr, apic_base; +uint64_t tpr;HRESULT hr;int idx;int idx_next;
@@ -779,13 +780,6 @@ void whpx_get_registers(CPUState *cpu, WHPXStateLevel level) env->kernelgsbase = vcxt.values[idx++].Reg64;#endif -assert (whpx_register_names[idx] == WHvX64RegisterApicBase); - apic_base = vcxt.values[idx++].Reg64; -if (apic_base != vcpu->apic_base) { - vcpu->apic_base = apic_base; -cpu_set_apic_base (x86_cpu->apic_state, vcpu->apic_base); - } -/* WHvX64RegisterPat - Skipped */ assert (whpx_register_names[idx] == WHvX64RegisterSysenterCs);
@@ -1997,8 +1991,7 @@ int whpx_vcpu_run(CPUState *cpu) val =X86_CPU (cpu)->env.apic_bus_freq; } -if (!whpx_irqchip_in_kernel () && - vcpu->exit_ctx.MsrAccess.MsrNumber ==MSR_IA32_APICBASE ) { +if (vcpu->exit_ctx.MsrAccess.MsrNumber ==MSR_IA32_APICBASE ) { is_known_msr =1 ;if (!vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite) {/* Read path unreachable on Hyper-V */
@@ -2164,6 +2157,13 @@ int whpx_vcpu_run(CPUState *cpu) }else { reg_values[2 ].Reg32 &= ~CPUID_EXT_X2APIC ; } + +/* CPUID[1:EDX].APIC is dynamic */ +if (env->features[FEAT_1_EDX ] &CPUID_APIC ) { + reg_values[3 ].Reg32 |=CPUID_APIC ; + }else { + reg_values[3 ].Reg32 &= ~CPUID_APIC ; + } }/* Dynamic depending on XCR0 and XSS, so query DefaultResult */
@@ -2725,9 +2725,7 @@ int whpx_accel_init(AccelState *as, MachineState *ms)memset (&prop,0 ,sizeof (WHV_PARTITION_PROPERTY )); prop.X64MsrExitBitmap.UnhandledMsrs =1 ; -if (!whpx_irqchip_in_kernel ()) { - prop.X64MsrExitBitmap.ApicBaseMsrWrite =1 ; - } + prop.X64MsrExitBitmap.ApicBaseMsrWrite =1 ; hr = whp_dispatch.WHvSetPartitionProperty( whpx->partition,
target/i386/whpx/whpx-apic.c +68 -3
90 lines not on this page · raw message
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 16/38 whpx: i386: set apicbase value only on success
In reply to Mohamed Mediouni--- target/i386/whpx/whpx-all.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
target/i386/whpx/whpx-all.c +2 -1
@@ -2001,8 +2001,9 @@ int whpx_vcpu_run(CPUState *cpu)int msr_ret =cpu_set_apic_base (X86_CPU (cpu)->apic_state, val);if (msr_ret <0 ) {x86_emul_raise_exception (&X86_CPU (cpu)->env,EXCP0D_GPF ,0 ); + }else { +whpx_set_reg (cpu, WHvX64RegisterApicBase, reg); } -whpx_set_reg (cpu, WHvX64RegisterApicBase, reg); } }
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 17/38 whpx: i386: unknown MSR configurability
In reply to Mohamed MediouniAdd an option to inject back a GPF for unknown MSRs.
Keep it on by default for now as Linux expects accesses to some AMD-specific MSRs to always succeed when on an AMD host.
--- accel/whpx/whpx-common.c | 38 ++++++++++++++++++++++++++++++++++ include/system/whpx-internal.h | 1 + target/i386/whpx/whpx-all.c | 4 ++++ 3 files changed, 43 insertions(+)
accel/whpx/whpx-common.c +38 -0
@@ -505,6 +505,38 @@ static void whpx_set_hyperv(Object *obj, Visitor *v, } } +static void whpx_set_unknown_msr (Object *obj,Visitor *v, +const char *name,void *opaque, +Error **errp) +{ +struct whpx_state *whpx = &whpx_global; +OnOffAuto mode; + +if (!visit_type_OnOffAuto (v, name, &mode, errp)) { +return ; + } + +switch (mode) { +case ON_OFF_AUTO_ON : + whpx->ignore_unknown_msr = true; +break ; + +case ON_OFF_AUTO_OFF : + whpx->ignore_unknown_msr = false; +break ; + +case ON_OFF_AUTO_AUTO : + whpx->ignore_unknown_msr = true; +break ; +default : +/* +* The value was checked in visit_type_OnOffAuto() above. If +* we get here, then something is wrong in QEMU. +*/ +abort (); + } +} +static void whpx_cpu_accel_class_init (ObjectClass *oc,const void *data) {AccelCPUClass *acc =ACCEL_CPU_CLASS (oc);
@@ -538,6 +570,11 @@ static void whpx_accel_class_init(ObjectClass *oc, const void *data) NULL, NULL);object_class_property_set_description (oc,"hyperv" ,"Configure Hyper-V enlightenments" ); +object_class_property_add (oc,"ignore-unknown-msr" ,"OnOffAuto" , +NULL , whpx_set_unknown_msr, +NULL ,NULL ); +object_class_property_set_description (oc,"ignore-unknown-msr" , +"Configure unknown MSR behavior" ); }static void whpx_accel_instance_init (Object *obj)
@@ -552,6 +589,7 @@ static void whpx_accel_instance_init(Object *obj) whpx->hyperv_enlightenments_required = false;/* Value determined at whpx_accel_init */ whpx->hyperv_enlightenments_enabled = false; + whpx->ignore_unknown_msr = true; }static const TypeInfo whpx_accel_type = {
include/system/whpx-internal.h +1 -0
@@ -47,6 +47,7 @@ struct whpx_state {bool hyperv_enlightenments_required;bool hyperv_enlightenments_enabled; +bool ignore_unknown_msr; };extern struct whpx_state whpx_global;
target/i386/whpx/whpx-all.c +4 -0
@@ -2048,6 +2048,10 @@ int whpx_vcpu_run(CPUState *cpu) vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite); } +if (!is_known_msr && !whpx->ignore_unknown_msr) { +x86_emul_raise_exception (&X86_CPU (cpu)->env,EXCP0D_GPF ,0 ); + } + hr = whp_dispatch.WHvSetVirtualProcessorRegisters( whpx->partition, cpu->cpu_index,
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 18/38 whpx: i386: enable GuestIdleReg enlightenment
In reply to Mohamed MediouniThis corresponds to HV_X64_MSR_GUEST_IDLE (0x400000f0).
This enlightenment is only available by the HV when using the Hyper-V LAPIC.
--- target/i386/whpx/whpx-all.c | 1 + 1 file changed, 1 insertion(+)
target/i386/whpx/whpx-all.c +1 -0
@@ -2686,6 +2686,7 @@ int whpx_accel_init(AccelState *as, MachineState *ms) synthetic_features.Bank0.AccessIntrCtrlRegs =1 ; synthetic_features.Bank0.SyntheticClusterIpi =1 ; synthetic_features.Bank0.DirectSyntheticTimers =1 ; + synthetic_features.Bank0.AccessGuestIdleReg =1 ;/* * These technically work without the Hyper-V LAPIC * but behave oddly for multi-core VMs.
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 19/38 whpx: i386: tighten APIC base validity check
In reply to Mohamed Mediouni--- target/i386/whpx/whpx-all.c | 3 +++ 1 file changed, 3 insertions(+)
target/i386/whpx/whpx-all.c +3 -0
@@ -1993,6 +1993,9 @@ int whpx_vcpu_run(CPUState *cpu)if (vcpu->exit_ctx.MsrAccess.MsrNumber ==MSR_IA32_APICBASE ) { is_known_msr =1 ; +if (val &MSR_IA32_APICBASE_RESERVED ) { +x86_emul_raise_exception (&X86_CPU (cpu)->env,EXCP0D_GPF ,0 ); + }if (!vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite) {/* Read path unreachable on Hyper-V */ abort ();
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 20/38 whpx: i386: ignore vpassist when kernel-irqchip=off
In reply to Mohamed MediouniLinux tries to set vpassist even when none of the enlightenments using it are available.
So ignore the page it sets.
--- target/i386/whpx/whpx-all.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
target/i386/whpx/whpx-all.c +13 -0
@@ -51,6 +51,7 @@#define HYPERV_APIC_BUS_FREQUENCY (200000000ULL)/* for kernel-irqchip=off */ #define HV_X64_MSR_APIC_FREQUENCY 0x40000023 +#define HV_X64_MSR_VP_ASSIST_PAGE 0x40000073static bool is_modern_os = true;
@@ -2033,6 +2034,18 @@ int whpx_vcpu_run(CPUState *cpu) } } } + +/* +* Linux tries to use it anyway even when not exposed. +* Ignore the write as the VP assist page is not used. +*/ +if (vcpu->exit_ctx.MsrAccess.MsrNumber ==HV_X64_MSR_VP_ASSIST_PAGE + && vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite + && !whpx_irqchip_in_kernel () + && whpx->hyperv_enlightenments_enabled) { + is_known_msr =1 ; + } +/* * For all unsupported MSR access we: * ignore writes
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 21/38 target: i386: HLT type that ignores EFLAGS.IF
In reply to Mohamed MediouniThe TLFS says:
Quoted 5 lines
A partition which possesses the AccessGuestIdleMsr privilege may trigger entry into the virtual processor idle sleep state through a read to the hypervisor-defined MSR
HV_X64_MSR_GUEST_IDLE. The virtual processor will be woken when an interrupt arrives, regardless of whether the interrupt is enabled on the virtual processor or not.
Meanwhile, Windows 24H2+ calls this MSR anyway without the privilege being set.
Add the infrastructure to support it on the generic QEMU side.
--- target/i386/cpu.c | 10 ++++++---- target/i386/cpu.h | 2 ++ 2 files changed, 8 insertions(+), 4 deletions(-)
target/i386/cpu.c +6 -4
@@ -10482,13 +10482,15 @@ int x86_cpu_pending_interrupt(CPUState *cs, int interrupt_request) (((env->hflags2 &HF2_VINTR_MASK ) && (env->hflags2 &HF2_HIF_MASK )) || (!(env->hflags2 &HF2_VINTR_MASK ) && - (env->eflags &IF_MASK && - !(env->hflags & HF_INHIBIT_IRQ_MASK))))) { + ((env->eflags &IF_MASK && + !(env->hflags &HF_INHIBIT_IRQ_MASK )) + || env->hflags2 & HF2_HYPERV_HLT_MASK)))) { return CPU_INTERRUPT_HARD; } else if (env->hflags2 & HF2_VGIF_MASK) {if ((interrupt_request &CPU_INTERRUPT_VIRQ ) && - (env->eflags &IF_MASK ) && - !(env->hflags &HF_INHIBIT_IRQ_MASK )) { + ((env->eflags &IF_MASK && + !(env->hflags &HF_INHIBIT_IRQ_MASK )) + || env->hflags2 &HF2_HYPERV_HLT_MASK )) {return CPU_INTERRUPT_VIRQ ; } }
target/i386/cpu.h +2 -0
@@ -225,6 +225,7 @@ typedef enum X86Seg {#define HF2_NPT_SHIFT 6/* Nested Paging enabled */ #define HF2_IGNNE_SHIFT 7/* Ignore CR0.NE=0 */ #define HF2_VGIF_SHIFT 8/* Can take VIRQ*/ +#define HF2_HYPERV_HLT_SHIFT 9/* Hyper-V HV_X64_MSR_GUEST_IDLE */ #define HF2_GIF_MASK (1 << HF2_GIF_SHIFT)#define HF2_HIF_MASK (1 << HF2_HIF_SHIFT)
@@ -235,6 +236,7 @@ typedef enum X86Seg {#define HF2_NPT_MASK (1 << HF2_NPT_SHIFT)#define HF2_IGNNE_MASK (1 << HF2_IGNNE_SHIFT)#define HF2_VGIF_MASK (1 << HF2_VGIF_SHIFT) +#define HF2_HYPERV_HLT_MASK (1 << HF2_HYPERV_HLT_SHIFT)#define CR0_PE_SHIFT 0#define CR0_MP_SHIFT 1
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 22/38 whpx: i386: add HV_X64_MSR_GUEST_IDLE when !kernel-irqchip
In reply to Mohamed MediouniAdd support for an oddball HV_X64_MSR_GUEST_IDLE not-quite-an-HLT that wakes the vCPU even if EFLAGS.IF is set.
--- target/i386/whpx/whpx-all.c | 46 ++++++++++++++++++++++++++++++++++--- 1 file changed, 43 insertions(+), 3 deletions(-)
target/i386/whpx/whpx-all.c +43 -3
@@ -52,6 +52,7 @@/* for kernel-irqchip=off */ #define HV_X64_MSR_APIC_FREQUENCY 0x40000023#define HV_X64_MSR_VP_ASSIST_PAGE 0x40000073 +#define HV_X64_MSR_GUEST_IDLE 0x400000f0static bool is_modern_os = true;
@@ -1543,13 +1544,16 @@ static vaddr whpx_vcpu_get_pc(CPUState *cpu, bool exit_context_valid) } } -static int whpx_handle_halt (CPUState *cpu) +static int whpx_handle_halt_generic (CPUState *cpu) { +X86CPU *x86_cpu =X86_CPU (cpu); +CPUX86State *env = &x86_cpu->env; +int ret =0 ;bql_lock ();if (!(cpu_test_interrupt (cpu,CPU_INTERRUPT_HARD ) && - (cpu_env (cpu)->eflags &IF_MASK )) && + ((cpu_env (cpu)->eflags &IF_MASK ) || env->hflags2 &HF2_HYPERV_HLT_MASK )) && !cpu_test_interrupt (cpu,CPU_INTERRUPT_NMI )) { cpu->exception_index =EXCP_HLT ; cpu->halted = true;
@@ -1560,6 +1564,27 @@ static int whpx_handle_halt(CPUState *cpu)return ret; } +static int whpx_handle_halt (CPUState *cpu) +{ +int ret =0 ; + + ret =whpx_handle_halt_generic (cpu); + +return ret; +} + +static int whpx_handle_hyperv_guestidle (CPUState *cpu) +{ +X86CPU *x86_cpu =X86_CPU (cpu); +CPUX86State *env = &x86_cpu->env; +int ret =0 ; + + env->hflags2 |=HF2_HYPERV_HLT_MASK ; + ret =whpx_handle_halt_generic (cpu); + +return ret; +} +static void whpx_vcpu_kick_out_of_hlt (CPUState *cpu) {WHV_REGISTER_VALUE reg;
@@ -1763,9 +1788,10 @@ static void whpx_vcpu_process_async_events(CPUState *cpu) }if ((cpu_test_interrupt (cpu,CPU_INTERRUPT_HARD ) && - (env->eflags &IF_MASK )) || + ((env->eflags &IF_MASK ) || env->hflags2 &HF2_HYPERV_HLT_MASK )) ||cpu_test_interrupt (cpu,CPU_INTERRUPT_NMI )) { cpu->halted = false; + env->hflags2 &= ~HF2_HYPERV_HLT_MASK ; }if (cpu_test_interrupt (cpu,CPU_INTERRUPT_SIPI )) {
@@ -2035,6 +2061,20 @@ int whpx_vcpu_run(CPUState *cpu) } } +/* +* Windows and Linux both use this MSR. +* Windows 11 25H2 uses it even when not advertised. +*/ +if (vcpu->exit_ctx.MsrAccess.MsrNumber ==HV_X64_MSR_GUEST_IDLE + && !vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite + && !whpx_irqchip_in_kernel () + && whpx->hyperv_enlightenments_enabled) { + is_known_msr =1 ; +whpx_bump_rip (cpu, &vcpu->exit_ctx); + ret =whpx_handle_hyperv_guestidle (cpu); +break ; + } +/* * Linux tries to use it anyway even when not exposed. * Ignore the write as the VP assist page is not used.
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 23/38 whpx: i386: one more CPUID
In reply to Mohamed MediouniTrap cpuid_0xb as it has x2APIC topology information.
--- target/i386/whpx/whpx-all.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/i386/whpx/whpx-all.c +1 -1
@@ -2527,7 +2527,7 @@ int whpx_accel_init(AccelState *as, MachineState *ms)WHV_PROCESSOR_FEATURES_BANKS processor_features;WHV_PROCESSOR_PERFMON_FEATURES perfmon_features; -UINT32 cpuidExitList[] = {0x0 ,0x1 ,0x6 ,0x7 ,0x14 ,0x24 ,0x29 ,0x1E , +UINT32 cpuidExitList[] = {0x0 ,0x1 ,0x6 ,0x7 ,0xb ,0x14 ,0x24 ,0x29 ,0x1E ,0x40000000 ,0x40000001 ,0x40000010 ,0x80000000 ,0x80000001 ,0x80000002 ,0x80000003 ,0x80000004 ,0x80000007 ,0x80000008 ,0x8000000A ,0x80000021 ,0x80000022 ,0xC0000000 ,0xC0000001 };
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 24/38 whpx: i386: some x2APIC awareness
In reply to Mohamed Mediouni--- target/i386/whpx/whpx-apic.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)
target/i386/whpx/whpx-apic.c +10 -2
@@ -33,7 +33,11 @@ static void whpx_put_apic_state(APICCommonState *s,int i;memset (kapic,0 ,sizeof (*kapic)); - kapic->fields[0x2 ].data = s->id <<24 ; +if (s->apicbase &MSR_IA32_APICBASE_EXTD ) { + kapic->fields[0x2 ].data = s->initial_apic_id; + }else { + kapic->fields[0x2 ].data = s->id <<24 ; + } kapic->fields[0x3 ].data = s->version | ((APIC_LVT_NB -1 ) <<16 ); kapic->fields[0x8 ].data = s->tpr; kapic->fields[0xd ].data = s->log_dest <<24 ;
@@ -61,7 +65,11 @@ static void whpx_get_apic_state(APICCommonState *s, {int i, v; - s->id = kapic->fields[0x2 ].data >>24 ; +if (s->apicbase &MSR_IA32_APICBASE_EXTD ) { +assert (kapic->fields[0x2 ].data == s->initial_apic_id); + }else { + s->id = kapic->fields[0x2 ].data >>24 ; + } s->tpr = kapic->fields[0x8 ].data; s->arb_id = kapic->fields[0x9 ].data; s->log_dest = kapic->fields[0xd ].data >>24 ;
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 25/38 whpx: i386: set WHvX64RegisterInitialApicId
In reply to Mohamed MediouniKeep Hyper-V aware of the initial APIC ID chosen.
--- target/i386/whpx/whpx-all.c | 5 +++++ 1 file changed, 5 insertions(+)
target/i386/whpx/whpx-all.c +5 -0
@@ -2398,6 +2398,11 @@ int whpx_init_vcpu(CPUState *cpu) goto error; } +if (!whpx_irqchip_in_kernel ()) { +WHV_REGISTER_VALUE apic_id = {.Reg64 = x86_cpu->apic_state->initial_apic_id}; +whpx_set_reg (cpu, WHvX64RegisterInitialApicId, apic_id); + } +/* * vcpu's TSC frequency is either specified by user, or use the value * provided by Hyper-V if the former is not present. In the latter case, we
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 26/38 whpx: i386: Pause VM on fatal exception to be able to inspect state
In reply to Mohamed Mediouni--- target/i386/whpx/whpx-all.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/i386/whpx/whpx-all.c +1 -1
@@ -2310,7 +2310,7 @@ int whpx_vcpu_run(CPUState *cpu) vcpu->exit_ctx.ExitReason);whpx_get_registers (cpu,WHPX_LEVEL_FULL_STATE );bql_lock (); -qemu_system_guest_panicked (cpu_get_crash_info (cpu)); +vm_stop (RUN_STATE_PAUSED );bql_unlock ();break ; }
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 27/38 target/i386: emulate: use exception_payload for fault address
In reply to Mohamed MediouniInstead of directly putting it in cr[2], put it in exception_payload.
--- target/i386/emulate/x86_mmu.c | 3 ++- target/i386/whpx/whpx-all.c | 6 +++--- 2 files changed, 5 insertions(+), 4 deletions(-)
target/i386/emulate/x86_mmu.c +2 -1
@@ -277,7 +277,8 @@ static MMUTranslateResult x86_write_mem_ex(CPUState *cpu, void *data, target_ulo translate_res =mmu_gva_to_gpa (cpu, gva, &gpa, translate_flags);if (translate_res) {int error_code =translate_res_to_error_code (translate_res, true,is_user (cpu)); - env->cr[2 ] = gva; + env->exception_has_payload =1 ; + env->exception_payload = gva;x86_emul_raise_exception (env,EXCP0E_PAGE , error_code);return translate_res; }
target/i386/whpx/whpx-all.c +3 -3
@@ -1818,11 +1818,11 @@ static void whpx_inject_exceptions(CPUState* cpu)WHV_REGISTER_VALUE reg = {}; reg.ExceptionEvent.EventPending =1 ; reg.ExceptionEvent.EventType = WHvX64PendingEventException; - reg.ExceptionEvent.DeliverErrorCode =1 ; + reg.ExceptionEvent.DeliverErrorCode = env->has_error_code; reg.ExceptionEvent.Vector = env->exception_nr; reg.ExceptionEvent.ErrorCode = env->error_code; -if (env->exception_nr ==EXCP0E_PAGE ) { - reg.ExceptionEvent.ExceptionParameter = env->cr[2 ]; +if (env->exception_has_payload) { + reg.ExceptionEvent.ExceptionParameter = env->exception_payload; }whpx_set_reg (cpu, WHvRegisterPendingEvent, reg); }
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 28/38 whpx: i386: CPU features support for Windows 10
In reply to Mohamed Mediouni--- target/i386/cpu.c | 18 +-- target/i386/whpx/meson.build | 1 + target/i386/whpx/whpx-all.c | 38 ++++++- target/i386/whpx/whpx-cpu-legacy.c | 171 +++++++++++++++++++++++++++++ target/i386/whpx/whpx-i386.h | 7 ++ 5 files changed, 215 insertions(+), 20 deletions(-) create mode 100644 target/i386/whpx/whpx-cpu-legacy.c
target/i386/cpu.c +4 -14
@@ -8092,9 +8092,6 @@ uint64_t x86_cpu_get_supported_feature_word(X86CPU *cpu, FeatureWord w) }else if (whpx_enabled ()) {if (wi->type !=CPUID_FEATURE_WORD ) {return 0 ; - } -if (whpx_is_legacy_os ()) { - r = wi->tcg_features; }else { r = whpx_get_supported_cpuid(wi->cpuid.eax, wi->cpuid.ecx,
@@ -8182,17 +8179,10 @@ static void x86_cpu_get_supported_cpuid(uint32_t func, uint32_t index, *ecx =hvf_get_supported_cpuid (func, index,R_ECX ); *edx =hvf_get_supported_cpuid (func, index,R_EDX ); }else if (whpx_enabled ()) { -if (whpx_is_legacy_os ()) { - *eax =0 ; - *ebx =0 ; - *ecx =0 ; - *edx =0 ; - }else { - *eax =whpx_get_supported_cpuid (func, index,R_EAX ); - *ebx =whpx_get_supported_cpuid (func, index,R_EBX ); - *ecx =whpx_get_supported_cpuid (func, index,R_ECX ); - *edx =whpx_get_supported_cpuid (func, index,R_EDX ); - } + *eax =whpx_get_supported_cpuid (func, index,R_EAX ); + *ebx =whpx_get_supported_cpuid (func, index,R_EBX ); + *ecx =whpx_get_supported_cpuid (func, index,R_ECX ); + *edx =whpx_get_supported_cpuid (func, index,R_EDX ); }else { *eax =0 ; *ebx =0 ;
target/i386/whpx/meson.build +1 -0
@@ -1,4 +1,5 @@ i386_system_ss.add(when: 'CONFIG_WHPX', if_true: files( 'whpx-all.c', 'whpx-apic.c', + 'whpx-cpu-legacy.c' ))
target/i386/whpx/whpx-all.c +32 -6
@@ -270,11 +270,30 @@ typedef enum WhpxStepMode {static uint32_t max_vcpu_index;static WHV_PROCESSOR_XSAVE_FEATURES whpx_xsave_cap; -static bool whpx_has_xsave (void ) +bool whpx_has_xsave (void ) {return whpx_xsave_cap.XsaveSupport; } +bool whpx_has_xsaves (void ) +{ +return whpx_xsave_cap.XsaveSupervisorSupport; +} + +static bool whpx_rdtsc_cap; + +bool whpx_has_rdtscp (void ) +{ +return whpx_rdtsc_cap; +} + +static bool whpx_invpcid_cap; + +bool whpx_has_invpcid (void ) +{ +return whpx_invpcid_cap; +} +static WHV_X64_SEGMENT_REGISTER whpx_seg_q2h (const SegmentCache *qs,int v86,int r86) {
@@ -1057,6 +1076,11 @@ uint32_t whpx_get_supported_cpuid(uint32_t func, uint32_t idx, int reg)bool temp_cpu = true;HRESULT hr; +/* Legacy OSes don't have WHvGetVirtualProcessorCpuidOutput */ +if (whpx_is_legacy_os ()) { +return whpx_get_supported_cpuid_legacy (func, idx, reg); + } + hr = whp_dispatch.WHvCreateVirtualProcessor ( whpx_global.partition, cpu_index,0 );
@@ -2147,7 +2171,7 @@ int whpx_vcpu_run(CPUState *cpu)* just pass through what the hypervisor * provides without any QEMU filtering. */ -if (whpx_is_legacy_os () || xcc->max_features) { +if (xcc->max_features) { reg_values[1 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRax; reg_values[2 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRcx; reg_values[3 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRdx;
@@ -2507,11 +2531,11 @@ void whpx_cpu_instance_init(CPUState *cs)host_cpu_instance_init (cpu);x86_cpu_apply_props (cpu, whpx_default_props); -if (!whpx_is_legacy_os () && xcc->max_features) { +if (xcc->max_features) {whpx_cpu_max_instance_init (cpu); } -if (!whpx_is_legacy_os ()) { +if (whpx_has_xsave ()) {whpx_cpu_xsave_init (); } }
@@ -2536,7 +2560,6 @@ int whpx_accel_init(AccelState *as, MachineState *ms)0x40000000 ,0x40000001 ,0x40000010 ,0x80000000 ,0x80000001 ,0x80000002 ,0x80000003 ,0x80000004 ,0x80000007 ,0x80000008 , 0x8000000A, 0x80000021, 0x80000022, 0xC0000000, 0xC0000001}; -UINT32 cpuidExitList_legacy_os[] = {1 ,0x40000000 ,0x40000001 ,0x40000010 };X86MachineState *x86ms =X86_MACHINE (ms);bool pic_enabled = false;
@@ -2700,6 +2723,9 @@ int whpx_accel_init(AccelState *as, MachineState *ms) goto error; } + whpx_rdtsc_cap = processor_features.Bank0.RdtscpSupport; + whpx_invpcid_cap = processor_features.Bank0.InvpcidSupport; +if (whpx_irqchip_in_kernel () && processor_features.Bank1.NestedVirtSupport) {memset (&prop,0 ,sizeof (WHV_PARTITION_PROPERTY )); prop.NestedVirtualization =1 ;
@@ -2808,7 +2834,7 @@ int whpx_accel_init(AccelState *as, MachineState *ms) hr = whp_dispatch.WHvSetPartitionProperty ( whpx->partition, WHvPartitionPropertyCodeCpuidExitList, - !whpx_is_legacy_os () ? cpuidExitList : cpuidExitList_legacy_os, + cpuidExitList,RTL_NUMBER_OF (cpuidExitList) *sizeof (UINT32 ));if (FAILED (hr)) {
target/i386/whpx/whpx-cpu-legacy.c new file +171 -0
171 lines not on this page · raw message
target/i386/whpx/whpx-i386.h +7 -0
@@ -2,3 +2,10 @@uint32_t whpx_get_supported_cpuid (uint32_t func,uint32_t idx,int reg);bool whpx_is_legacy_os (void ); + +uint32_t whpx_get_supported_cpuid_legacy (uint32_t func,uint32_t idx, +int reg); +bool whpx_has_xsave (void ); +bool whpx_has_xsaves (void ); +bool whpx_has_rdtscp (void ); +bool whpx_has_invpcid (void );
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 29/38 target/i386: make xsave_buf present unconditionally
In reply to Mohamed MediouniThis is necessary for the xsave_helper helpers to compile.
--- target/i386/cpu.h | 2 -- 1 file changed, 2 deletions(-)
target/i386/cpu.h +0 -2
@@ -2269,10 +2269,8 @@ typedef struct CPUArchState {int64_t user_tsc_khz;/* for sanity check only */ uint64_t apic_bus_freq;uint64_t tsc; -#if defined(CONFIG_KVM ) || defined(CONFIG_HVF )void *xsave_buf;uint32_t xsave_buf_len; -#endif #if defined(CONFIG_KVM )struct kvm_nested_state *nested_state;MemoryRegion *xen_vcpu_info_mr;
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 30/38 target/i386: add de/compaction to xsave_helper
In reply to Mohamed MediouniFrom: Magnus Kulke <[email protected]>
HyperV use XSAVES which stores extended state in compacted format in which components are packed contiguously, while QEMU's internal XSAVE representation use the standard format in which each component is places at a fixed offset. Hence for this purpose we add two conversion fn's to the xsave helper to roundtrip XSAVE state in a migration.
- decompact_xsave_area(): converts compacted format to standard. XSTATE_BV is masked to host XCR0 since IA32_XSS is managed by the hypervisor.
- compact_xsave_area(): converts standard format back to compacted format. XCOMP_BV is set from the host's CPUID 0xD.0 rather than the guest's XCR0, as this is what the hypervisor expects.
Both functions use the host's CPUID leaf 0xD subleaves to determine component sizes, offsets, and alignment requirements.
There are situations when the host advertises features that we want to disable for the guest, e.g. AMX TILE. In this case we cannot rely on the host's xcr0, but instead we use the feature mask that has been generated in as part of the CPU realization process (x86_cpu_expand_features).
--- target/i386/cpu.h | 2 + target/i386/xsave_helper.c | 255 +++++++++++++++++++++++++++++++++++++ 2 files changed, 257 insertions(+)
target/i386/cpu.h +2 -0
@@ -3023,6 +3023,8 @@ void x86_cpu_xrstor_all_areas(X86CPU *cpu, const void *buf, uint32_t buflen);void x86_cpu_xsave_all_areas (X86CPU *cpu,void *buf,uint32_t buflen);uint32_t xsave_area_size (uint64_t mask,bool compacted);void x86_update_hflags (CPUX86State * env); +int decompact_xsave_area (const void *buf,size_t buflen,CPUX86State *env); +int compact_xsave_area (CPUX86State *env,void *buf,size_t buflen);static inline bool hyperv_feat_enabled (X86CPU *cpu,int feat) {
target/i386/xsave_helper.c +255 -0
264 lines not on this page · raw message
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 31/38 whpx: xsave support
In reply to Mohamed Mediouni--- include/system/whpx-internal.h | 16 ++ target/i386/whpx/whpx-all.c | 378 ++++++++++++++++++++++++--------- 2 files changed, 291 insertions(+), 103 deletions(-)
include/system/whpx-internal.h +16 -0
@@ -99,6 +99,22 @@ void whpx_apic_get(APICCommonState *s); UINT32 StateSize)) \ X(HRESULT, WHvResetPartition, \ (WHV_PARTITION_HANDLE Partition)) \ + X(HRESULT, WHvGetVirtualProcessorXsaveState, \ + (WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, \ + PVOID Buffer, \ + UINT32 BufferSizeInBytes, UINT32 *BytesWritten)) \ + X(HRESULT, WHvSetVirtualProcessorXsaveState, \ + (WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, \ + PVOID Buffer, \ + UINT32 BufferSizeInBytes)) \ + X(HRESULT, WHvGetVirtualProcessorState, \ + (WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, \ + WHV_VIRTUAL_PROCESSOR_STATE_TYPE StateType, PVOID Buffer, \ + UINT32 BufferSizeInBytes, UINT32 *BytesWritten)) \ + X(HRESULT, WHvSetVirtualProcessorState, \ + (WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, \ + WHV_VIRTUAL_PROCESSOR_STATE_TYPE StateType, PVOID Buffer, \ + UINT32 BufferSizeInBytes)) \ LIST_WINHVPLATFORM_FUNCTIONS_SUPPLEMENTAL_ARCH(X) #define WHP_DEFINE_TYPE(return_type, function_name, signature) \
target/i386/whpx/whpx-all.c +275 -103
452 lines not on this page · raw message
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 32/38 whpx: i386: set APIC ID only when APIC present
In reply to Mohamed Mediouni-M isapc doesn't have an APIC
--- target/i386/whpx/whpx-all.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/i386/whpx/whpx-all.c +1 -1
@@ -2589,7 +2589,7 @@ int whpx_init_vcpu(CPUState *cpu) goto error; } -if (!whpx_irqchip_in_kernel ()) { +if (!whpx_irqchip_in_kernel () && x86_cpu->apic_state !=NULL ) {WHV_REGISTER_VALUE apic_id = {.Reg64 = x86_cpu->apic_state->initial_apic_id};whpx_set_reg (cpu, WHvX64RegisterInitialApicId, apic_id); }
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 33/38 whpx: i386: update migration blocker message
In reply to Mohamed MediouniQuite a part of it is from older times...
--- target/i386/whpx/whpx-all.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
target/i386/whpx/whpx-all.c +2 -2
@@ -2568,8 +2568,8 @@ int whpx_init_vcpu(CPUState *cpu)*/ if (whpx_migration_blocker ==NULL ) {error_setg (&whpx_migration_blocker, -"State blocked due to non-migratable CPUID feature support," -"dirty memory tracking support, and XSAVE/XRSTOR support" ); +"State blocked due to missing dirty memory tracking support," +"And some system register/state save-restore " );if (migrate_add_blocker (&whpx_migration_blocker, &local_error) <0 ) {error_report_err (local_error);
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 34/38 whpx: i386: don't increment eip on MSR access raising GPF
In reply to Mohamed Mediouni--- target/i386/whpx/whpx-all.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
target/i386/whpx/whpx-all.c +12 -0
@@ -2178,6 +2178,7 @@ int whpx_vcpu_run(CPUState *cpu)WHV_REGISTER_NAME reg_names[3 ];UINT32 reg_count;bool is_known_msr =0 ; +bool raises_gpf = false;uint64_t val;if (vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite) {
@@ -2210,6 +2211,7 @@ int whpx_vcpu_run(CPUState *cpu) is_known_msr =1 ;if (val &MSR_IA32_APICBASE_RESERVED ) {x86_emul_raise_exception (&X86_CPU (cpu)->env,EXCP0D_GPF ,0 ); + raises_gpf = true; }if (!vcpu->exit_ctx.MsrAccess.AccessInfo.IsWrite) {/* Read path unreachable on Hyper-V */
@@ -2219,6 +2221,7 @@ int whpx_vcpu_run(CPUState *cpu)int msr_ret =cpu_set_apic_base (X86_CPU (cpu)->apic_state, val);if (msr_ret <0 ) {x86_emul_raise_exception (&X86_CPU (cpu)->env,EXCP0D_GPF ,0 ); + raises_gpf = true; }else {whpx_set_reg (cpu, WHvX64RegisterApicBase, reg); }
@@ -2238,6 +2241,7 @@ int whpx_vcpu_run(CPUState *cpu) reg_values[1 ].Reg64 = val;if (msr_ret <0 ) {x86_emul_raise_exception (&X86_CPU (cpu)->env,EXCP0D_GPF ,0 ); + raises_gpf = true; } }else {bql_lock ();
@@ -2245,6 +2249,7 @@ int whpx_vcpu_run(CPUState *cpu)bql_unlock ();if (msr_ret <0 ) {x86_emul_raise_exception (&X86_CPU (cpu)->env,EXCP0D_GPF ,0 ); + raises_gpf = true; } } }
@@ -2294,6 +2299,13 @@ int whpx_vcpu_run(CPUState *cpu)if (!is_known_msr && !whpx->ignore_unknown_msr) {x86_emul_raise_exception (&X86_CPU (cpu)->env,EXCP0D_GPF ,0 ); + raises_gpf = true; + } + +/* When a GPF is raised, do not change Rip. */ +if (raises_gpf) { + reg_values[0 ].Reg64 = + vcpu->exit_ctx.VpContext.Rip; } hr = whp_dispatch.WHvSetVirtualProcessorRegisters(
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 35/38 target/i386: emulate, hvf: rdmsr/wrmsr GPF handling
In reply to Mohamed MediouniIn that case, the instruction pointer mustn't be incremented.
--- target/i386/emulate/x86_emu.c | 10 ++++++---- target/i386/emulate/x86_emu.h | 4 ++-- target/i386/hvf/hvf.c | 9 +++++++-- 3 files changed, 15 insertions(+), 8 deletions(-)
target/i386/emulate/x86_emu.c +6 -4
@@ -792,15 +792,17 @@ void x86_emul_raise_exception(CPUX86State *env, int exception_index, int error_cstatic bool exec_rdmsr (CPUX86State *env,struct x86_decode *decode) { - emul_ops->simulate_rdmsr (env_cpu (env)); - env->eip += decode->len; +if (!emul_ops->simulate_rdmsr (env_cpu (env))) { + env->eip += decode->len; + }return 0 ; }static bool exec_wrmsr (CPUX86State *env,struct x86_decode *decode) { - emul_ops->simulate_wrmsr (env_cpu (env)); - env->eip += decode->len; +if (!emul_ops->simulate_wrmsr (env_cpu (env))) { + env->eip += decode->len; + }return 0 ; }
target/i386/emulate/x86_emu.h +2 -2
@@ -31,8 +31,8 @@ struct x86_emul_ops {target_ulong (*read_cr) (CPUState *cpu,int cr);void (*handle_io)(CPUState *cpu,uint16_t port,void *data,int direction,int size,int count); -void (*simulate_rdmsr)(CPUState *cs); -void (*simulate_wrmsr)(CPUState *cs); +bool (*simulate_rdmsr)(CPUState *cs); +bool (*simulate_wrmsr)(CPUState *cs);bool (*is_protected_mode)(CPUState *cpu);bool (*is_long_mode)(CPUState *cpu);bool (*is_user_mode)(CPUState *cpu);
target/i386/hvf/hvf.c +7 -2
@@ -536,7 +536,7 @@ void hvf_store_regs(CPUState *cs)macvm_set_rip (cs, env->eip); } -void hvf_simulate_rdmsr (CPUState *cs) +bool hvf_simulate_rdmsr (CPUState *cs) {X86CPU *cpu =X86_CPU (cs);CPUX86State *env = &cpu->env;
@@ -557,6 +557,7 @@ void hvf_simulate_rdmsr(CPUState *cs) ret =apic_msr_read (cpu->apic_state, index, &val);if (ret <0 ) {x86_emul_raise_exception (env,EXCP0D_GPF ,0 ); +return 1 ; }break ;
@@ -639,9 +640,10 @@ void hvf_simulate_rdmsr(CPUState *cs)RAX (env) = (uint32_t )val;RDX (env) = (uint32_t )(val >>32 ); +return 0 ; } -void hvf_simulate_wrmsr (CPUState *cs) +bool hvf_simulate_wrmsr (CPUState *cs) {X86CPU *cpu =X86_CPU (cs);CPUX86State *env = &cpu->env;
@@ -657,6 +659,7 @@ void hvf_simulate_wrmsr(CPUState *cs) r =cpu_set_apic_base (cpu->apic_state, data);if (r <0 ) {x86_emul_raise_exception (env,EXCP0D_GPF ,0 ); +return 1 ; }break ;
@@ -668,6 +671,7 @@ void hvf_simulate_wrmsr(CPUState *cs) ret =apic_msr_write (cpu->apic_state, index, data);if (ret <0 ) {x86_emul_raise_exception (env,EXCP0D_GPF ,0 ); +return 1 ; }break ;
@@ -746,6 +750,7 @@ void hvf_simulate_wrmsr(CPUState *cs)g_hypervisor_iface->wrmsr_handler(cs, msr, data); printf("write msr %llx\n", RCX(cs));*/ +return 0 ; }static int hvf_handle_vmexit (CPUState *cpu)
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 36/38 whpx: i386: add feature to intercept #GP MSR accesses
In reply to Mohamed MediouniIt turns out they're not that uncommon, so have
a feature around to log those.
--- accel/whpx/whpx-common.c | 38 +++++++++ include/system/whpx-internal.h | 1 + target/i386/whpx/whpx-all.c | 144 ++++++++++++++++++++++++++++----- 3 files changed, 164 insertions(+), 19 deletions(-)
accel/whpx/whpx-common.c +38 -0
@@ -537,6 +537,38 @@ static void whpx_set_unknown_msr(Object *obj, Visitor *v, } } +static void whpx_set_intercept_msr_gp (Object *obj,Visitor *v, +const char *name,void *opaque, +Error **errp) +{ +struct whpx_state *whpx = &whpx_global; +OnOffAuto mode; + +if (!visit_type_OnOffAuto (v, name, &mode, errp)) { +return ; + } + +switch (mode) { +case ON_OFF_AUTO_ON : + whpx->intercept_msr_gp = true; +break ; + +case ON_OFF_AUTO_OFF : + whpx->intercept_msr_gp = false; +break ; + +case ON_OFF_AUTO_AUTO : + whpx->intercept_msr_gp = false; +break ; +default : +/* +* The value was checked in visit_type_OnOffAuto() above. If +* we get here, then something is wrong in QEMU. +*/ +abort (); + } +} +static void whpx_cpu_accel_class_init (ObjectClass *oc,const void *data) {AccelCPUClass *acc =ACCEL_CPU_CLASS (oc);
@@ -575,6 +607,11 @@ static void whpx_accel_class_init(ObjectClass *oc, const void *data) NULL, NULL);object_class_property_set_description (oc,"ignore-unknown-msr" ,"Configure unknown MSR behavior" ); +object_class_property_add (oc,"intercept-msr-gp" ,"OnOffAuto" , +NULL , whpx_set_intercept_msr_gp, +NULL ,NULL ); +object_class_property_set_description (oc,"intercept-msr-gp" , +"Intercept #GP to log erroring MSR accesses." ); }static void whpx_accel_instance_init (Object *obj)
@@ -590,6 +627,7 @@ static void whpx_accel_instance_init(Object *obj)/* Value determined at whpx_accel_init */ whpx->hyperv_enlightenments_enabled = false; whpx->ignore_unknown_msr = true; + whpx->intercept_msr_gp = false; }static const TypeInfo whpx_accel_type = {
include/system/whpx-internal.h +1 -0
@@ -48,6 +48,7 @@ struct whpx_state {bool hyperv_enlightenments_enabled;bool ignore_unknown_msr; +bool intercept_msr_gp; };extern struct whpx_state whpx_global;
target/i386/whpx/whpx-all.c +125 -19
204 lines not on this page · raw message
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 37/38 whpx: i386: intercept CPUID 0xD too
In reply to Mohamed MediouniTo have a more accurate CPU model.
--- target/i386/whpx/whpx-all.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)
target/i386/whpx/whpx-all.c +9 -1
@@ -2565,6 +2565,14 @@ int whpx_vcpu_run(CPUState *cpu) } } +/* CPUID[0xD,{1,2}].EBX are dynamic depending on guest features. */ +if (vcpu->exit_ctx.CpuidAccess.Rax ==0xd ) { +if (vcpu->exit_ctx.CpuidAccess.Rcx ==1 + || vcpu->exit_ctx.CpuidAccess.Rcx ==2 ) { + reg_values[4 ].Reg64 = vcpu->exit_ctx.CpuidAccess.DefaultResultRbx; + } + } +/* OSXSAVE is dynamic. Do this instead of syncing CR4 */ if (vcpu->exit_ctx.CpuidAccess.Rax ==1 ) { if (vcpu->exit_ctx.CpuidAccess.DefaultResultRcx
@@ -2866,7 +2874,7 @@ int whpx_accel_init(AccelState *as, MachineState *ms)WHV_PROCESSOR_FEATURES_BANKS processor_features;WHV_PROCESSOR_PERFMON_FEATURES perfmon_features; -UINT32 cpuidExitList[] = {0x0 ,0x1 ,0x6 ,0x7 ,0xb ,0x14 ,0x24 ,0x29 ,0x1E , +UINT32 cpuidExitList[] = {0x0 ,0x1 ,0x6 ,0x7 ,0xb ,0xd ,0x14 ,0x24 ,0x29 ,0x1E ,0x40000000 ,0x40000001 ,0x40000010 ,0x80000000 ,0x80000001 ,0x80000002 ,0x80000003 ,0x80000004 ,0x80000007 ,0x80000008 ,0x8000000A ,0x80000021 ,0x80000022 ,0xC0000000 ,0xC0000001 };
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH 38/38 whpx: i386: documentation update
In reply to Mohamed Mediouni--- docs/system/whpx.rst | 30 +++++------------------------- 1 file changed, 5 insertions(+), 25 deletions(-)
docs/system/whpx.rst +5 -25
@@ -96,38 +96,18 @@ MMX, SSE or AVX instructions for access to MMIO memory ranges. Attempts to run such guests will result in an ``Unimplemented handler`` warning for MMX and a failure to decode for newer instructions. -``-M isapc`` -^^^^^^^^^^^^ - -``-M isapc`` doesn't disable the Hyper-V LAPIC on its own yet. To -be able to use that machine, use ``-accel whpx,hyperv=off,kernel-irqchip=off``. - -However, in QEMU 11.0, the guest will still be a 64-bit x86 -ISA machine with all the corresponding CPUID leaves exposed. - -gdbstub -^^^^^^^ - -As save/restore of xsave state is not currently present, state -exposed through GDB will be incomplete. - -The same also applies to ``info registers``. - -``-cpu type`` ignored -^^^^^^^^^^^^^^^^^^^^^ - -In this release, -cpu is an ignored argument. - PIC interrupts on Windows 10 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ On Windows 10, a legacy PIC interrupt injected does not wake the guest from an HLT when using the Hyper-V provided interrupt controller. -This has been addressed in QEMU 11.0 on Windows 11 platforms but -functionality to make it available on Windows 10 isn't present. +As such, on Windows 10, using the Hyper-V interrupt controller is +disabled by default. You can enable it via ``-M q35,pic=off`` which +disables the PIC. In that configuration, using a UEFI is recommended. -Workaround: for affected use cases, use ``-M kernel-irqchip=off``. +On this release, ``-M kernel-irqchip=`` is not expected to be manually +set during normal operation. It remains as a debugging option. Known issues on Windows 11 ^^^^^^^^^^^^^^^^^^^^^^^^^^
Signature · 1 line
2.50.1 (Apple Git-155)