whpx: i386: bug fixes, feature probing and CPUID
v9 cover whpx: i386: bug fixes, feature probing and CPUID
This is a supplemental update that includes
"whpx: i386: x2apic emulation for kernel-irqchip=off, feature probing" v4 unmodified.
This might be too big for QEMU 11.0 at this point though...
"whpx: i386: disable TbFlushHypercalls for emulated LAPIC" is a bugfix, and "target/i386: emulate: include name of unhandled instruction" is a debugging aid.
"whpx: i386: x2apic emulation" makes things slightly better for Windows 10 users. But I strongly recommend *not* relying on it when possible and using kernel-irqchip=on instead. On Windows 10 however that's more murky because PIC interrupt injection is broken (interrupts don't wake the vCPU from HLT) in that case.
"whpx: i386: wire up feature probing" is yet another commit adding a code path not used on Windows 10. It'll tell the user today which CPU features they set are incompatible with the hardware but it does not sync that to the CPUID view that the guest has.
And then another commit to enable x2apic emulation by default even for kernel-irqchip=off + re-introducing provided by QEMU enlightenments in a more functional form to signal that the x2apic can be used. I'm not aware of the actual vmware freq leaf being used though.
"whpx: x2apic emulation for kernel-irqchip=off follow-up" is rolled into this series.
"whpx: i386: reintroduce enlightenments for Windows 10" is a bugfix to make x2APIC work as intended on Windows 10 without emulating an IOMMU. *And* a massive improvement for Windows 10 hosts in performance for Linux guests due to using the right clocksource instead of HPET.
And dependent on this series so included, CPUID intercepts finally... However that's only supported starting from Windows 11/Server 2022.
Also ended up switching over Windows 10 to kernel-irqchip=off by default due to PIC interrupt injection being broken.
Old performance (or lack thereof...) numbers:
On a Ryzen 7 8700GE with a Windows 10 VM running with KVM in nested virt, with kernel-irqchip=off for the virt Alpine Linux x86_64 ISO (3.23.3) with -smp cores=2, boot times as reported through dmesg:
- QEMU 10.2: 83 seconds
- QEMU 10.2 with a single core: 18.1 seconds
- as of v6 of this series, x2apic forced off: 29 seconds
- as of v6 this series, out of the box: 18 seconds
- v6 with kernel-irqchip=on and EDK2: 16.5 seconds
- v6 with kernel-irqchip=off and EDK2: 9.5 seconds
- v6, and with 1 core instead of two: 12.6 seconds
In v7, the Windows 10 numbers are pretty much at parity with Windows 11 now.
And with this series on a Windows 11 VM on the same hardware:
- kernel-irqchip=on: 6.5 seconds
- kernel-irqchip=on, x2apic forced off: 7.6 seconds
- kernel-irqchip=off: 8.3 seconds
- hyperv=off,kernel-irqchip=off: 7.6 seconds... which is faster, so the absence of enlightenment support on Windows 10 doesn't explain things...
With kernel-irqchip=on on Windows 10, when booting with SeaBIOS, it gets stuck in syslinux due to PIC interrupt injection being broken there. That can be counted as an infinite boot time (?).
checkpatch false positives:
ERROR: spaces required around that '*' (ctx:WxV)
+ UINT32 Ecx, WHV_CPUID_OUTPUT *CpuidOutput))
Not a multiplication but a pointer reference.
ERROR: space prohibited after that '&' (ctx:ExW)
+ & CPUID_7_0_EDX_CET_IBT) {
^ERROR: space prohibited after that '&' (ctx:ExW)
+ & CPUID_7_0_ECX_CET_SHSTK) {
^Because it's multiline.
Changes in v9:
- Oops, "if (irr == -1)" change (and cleanup)
to avoid an abort(). And think that I understand this a bit better now.
Changes in v8:
- Interrupt priority changes are back.
- Some CPUID fixes
- disable enlightenments and LAPIC for isapc
Changes in v7:
- Exposing VMware hypervisor identification when not using Hyper-V enlightenments and when the VMware frequency CPUID leaf isn't explictly disabled.
- Remove the interrupt priority logic as it has issues with PIC interrupts. Can be reintroduced later.
- -cpu max passing through CPUID info from Hyper-V
- fill xsave info
- OSXSAVE CPUID leaf reporting fix.
Changes in v6:
- kernel-irqchip=off fix: re-registering the interrupt window when the existing one has too low of a TPR value.
Folded into "whpx: i386: kernel-irqchip=off fixes".
- I/O port access fast path cleanup commit added at the end
The path relied on a side effect of whpx_get_reg instead of something cleaner.
- Use the CR8 register provided by the hypervisor only when kernel-irqchip=off. Rely on the APIC state synchronisation otherwise.
This fixes some register sync errors that surfaced when setting the TPR values properly.
Changes in v5/v1 with rename:
- kernel-irqchip=off fixes, notably making 64-bit Windows bootable
- switching over Windows 10 to kernel-irqchip=off by default
Changes in v4:
- Ugh for a revision sent quickly, unbreaking the arm64 build...
- and making checkpatch happier to some extent
Changes in v3:
- Fixing CPUID intercepts so that QEMU CPU models work fine now, instead of the partial intercept that was present in QEMU 10.2
- cleanups
Changes in v2:
- GCC warned when a variable name was re-used within a different (but overlapping) scope in the same function. It also warned with a -Werror=maybe-uninitialized for the MSR write case. Address those
- make the in-KVM enlightenments path available on Windows 11 too when -M hyperv=off.
Mohamed Mediouni (13):
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
accel/whpx/whpx-common.c | 2 + include/system/whpx-common.h | 1 + include/system/whpx-internal.h | 10 + target/arm/whpx/whpx-all.c | 1 + target/i386/cpu.c | 25 ++ target/i386/emulate/x86_emu.c | 4 +- target/i386/whpx/whpx-all.c | 577 +++++++++++++++++++++++++++------ target/i386/whpx/whpx-i386.h | 4 + 8 files changed, 527 insertions(+), 97 deletions(-) create mode 100644 target/i386/whpx/whpx-i386.h
Signature · 1 line
2.50.1 (Apple Git-155)
PATCH v9 1/13 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 v9 2/13 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 v9 3/13 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 v9 4/13 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 v9 5/13 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 v9 6/13 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 v9 7/13 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 v9 8/13 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 v9 9/13 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 v9 10/13 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 v9 11/13 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 v9 12/13 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 v9 13/13 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 (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)