KVM: x86: Clean up "force immediate exit" code
Sean Christopherson
maintainercover KVM: x86: Clean up "force immediate exit" code
Plumb "force_immediate_exit" into the kvm_entry() tracepoint, as suggested by Maxim, and then follow that up with cleanups that are made possible by having force_immediate_exit made available to .vcpu_run(), e.g. VMX can use the on-stack param instead of what is effectively a temporary field in vcpu_vmx.
Sean Christopherson (6):
KVM: x86: Plumb "force_immediate_exit" into kvm_entry() tracepoint
KVM: VMX: Re-enter guest in fastpath for "spurious" preemption timer
exits
KVM: VMX: Handle forced exit due to preemption timer in fastpath
KVM: x86: Move handling of is_guest_mode() into fastpath exit handlers
KVM: VMX: Handle KVM-induced preemption timer exits in fastpath for L2
KVM: x86: Fully defer to vendor code to decide how to force immediate
exit
arch/x86/include/asm/kvm-x86-ops.h | 1 - arch/x86/include/asm/kvm_host.h | 6 +-- arch/x86/kvm/svm/svm.c | 18 ++++--- arch/x86/kvm/trace.h | 9 ++-- arch/x86/kvm/vmx/vmx.c | 80 +++++++++++++++++++----------- arch/x86/kvm/vmx/vmx.h | 2 - arch/x86/kvm/x86.c | 12 +---- 7 files changed, 72 insertions(+), 56 deletions(-)
base-commit: 1c6d984f523f67ecfad1083bb04c55d91977bb15
Signature · 1 line
2.43.0.472.g3155946c3a-goog
Sean Christopherson
maintainerPATCH 1/6 KVM: x86: Plumb "force_immediate_exit" into kvm_entry() tracepoint
Annotate the kvm_entry() tracepoint with "immediate exit" when KVM is forcing a VM-Exit immediately after VM-Enter, e.g. when KVM wants to inject an event but needs to first complete some other operation. Knowing that KVM is (or isn't) forcing an exit is useful information when debugging issues related to event injection.
--- arch/x86/include/asm/kvm_host.h | 3 ++- arch/x86/kvm/svm/svm.c | 5 +++-- arch/x86/kvm/trace.h | 9 ++++++--- arch/x86/kvm/vmx/vmx.c | 4 ++-- arch/x86/kvm/x86.c | 2 +- 5 files changed, 14 insertions(+), 9 deletions(-)
arch/x86/include/asm/kvm_host.h +2 -1
@@ -1663,7 +1663,8 @@ struct kvm_x86_ops {void (*flush_tlb_guest)(struct kvm_vcpu *vcpu);int (*vcpu_pre_run)(struct kvm_vcpu *vcpu); -enum exit_fastpath_completion (*vcpu_run)(struct kvm_vcpu *vcpu); +enum exit_fastpath_completion (*vcpu_run)(struct kvm_vcpu *vcpu, +bool force_immediate_exit);int (*handle_exit)(struct kvm_vcpu *vcpu,enum exit_fastpath_completion exit_fastpath);int (*skip_emulated_instruction)(struct kvm_vcpu *vcpu);
arch/x86/kvm/svm/svm.c +3 -2
@@ -4115,12 +4115,13 @@ static noinstr void svm_vcpu_enter_exit(struct kvm_vcpu *vcpu, bool spec_ctrl_inguest_state_exit_irqoff (); } -static __no_kcsan fastpath_t svm_vcpu_run(struct kvm_vcpu *vcpu) +static __no_kcsan fastpath_t svm_vcpu_run(struct kvm_vcpu *vcpu, +bool force_immediate_exit) {struct vcpu_svm *svm =to_svm (vcpu);bool spec_ctrl_intercepted =msr_write_intercepted (vcpu,MSR_IA32_SPEC_CTRL ); -trace_kvm_entry (vcpu); +trace_kvm_entry (vcpu, force_immediate_exit); svm->vmcb->save.rax = vcpu->arch.regs[VCPU_REGS_RAX ]; svm->vmcb->save.rsp = vcpu->arch.regs[VCPU_REGS_RSP ];
arch/x86/kvm/trace.h +6 -3
@@ -15,20 +15,23 @@* Tracepoint for guest mode entry. */ TRACE_EVENT (kvm_entry, - TP_PROTO(struct kvm_vcpu *vcpu), -TP_ARGS (vcpu), + TP_PROTO(struct kvm_vcpu *vcpu, bool force_immediate_exit), +TP_ARGS (vcpu, force_immediate_exit),TP_STRUCT__entry ( __field( unsigned int, vcpu_id ) __field( unsigned long, rip ) +__field ( bool, immediate_exit ) ),TP_fast_assign ( __entry->vcpu_id = vcpu->vcpu_id; __entry->rip = kvm_rip_read(vcpu); + __entry->immediate_exit = force_immediate_exit; ), -TP_printk ("vcpu %u, rip 0x%lx" , __entry->vcpu_id, __entry->rip) +TP_printk ("vcpu %u, rip 0x%lx%s" , __entry->vcpu_id, __entry->rip, + __entry->immediate_exit ?"[immediate exit]" :"" ) );/*
arch/x86/kvm/vmx/vmx.c +2 -2
@@ -7268,7 +7268,7 @@ static noinstr void vmx_vcpu_enter_exit(struct kvm_vcpu *vcpu,guest_state_exit_irqoff (); } -static fastpath_t vmx_vcpu_run (struct kvm_vcpu *vcpu) +static fastpath_t vmx_vcpu_run (struct kvm_vcpu *vcpu,bool force_immediate_exit) {struct vcpu_vmx *vmx =to_vmx (vcpu);unsigned long cr3, cr4;
@@ -7295,7 +7295,7 @@ static fastpath_t vmx_vcpu_run(struct kvm_vcpu *vcpu)return EXIT_FASTPATH_NONE ; } -trace_kvm_entry (vcpu); +trace_kvm_entry (vcpu, force_immediate_exit);if (vmx->ple_window_dirty) { vmx->ple_window_dirty = false;
arch/x86/kvm/x86.c +1 -1
@@ -10962,7 +10962,7 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)WARN_ON_ONCE ((kvm_vcpu_apicv_activated (vcpu) !=kvm_vcpu_apicv_active (vcpu)) && (kvm_get_apic_mode (vcpu) !=LAPIC_MODE_DISABLED )); - exit_fastpath =static_call (kvm_x86_vcpu_run)(vcpu); + exit_fastpath =static_call (kvm_x86_vcpu_run)(vcpu, req_immediate_exit);if (likely (exit_fastpath !=EXIT_FASTPATH_REENTER_GUEST ))break ;
Signature · 1 line
2.43.0.472.g3155946c3a-goog
Sean Christopherson
maintainerPATCH 2/6 KVM: VMX: Re-enter guest in fastpath for "spurious" preemption timer exits
In reply to Sean ChristophersonRe-enter the guest in the fast path if VMX preeemption timer VM-Exit was "spurious", i.e. if KVM "soft disabled" the timer by writing -1u and by some miracle the timer expired before any other VM-Exit occurred. This is just an intermediate step to cleaning up the preemption timer handling, optimizing these types of spurious VM-Exits is not interesting as they are extremely rare/infrequent.
--- arch/x86/kvm/vmx/vmx.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)
arch/x86/kvm/vmx/vmx.c +9 -2
@@ -5995,8 +5995,15 @@ static fastpath_t handle_fastpath_preemption_timer(struct kvm_vcpu *vcpu) {struct vcpu_vmx *vmx =to_vmx (vcpu); -if (!vmx->req_immediate_exit && - !unlikely (vmx->loaded_vmcs->hv_timer_soft_disabled)) { +/* +* In the *extremely* unlikely scenario that this is a spurious VM-Exit +* due to the timer expiring while it was "soft" disabled, just eat the +* exit and re-enter the guest. +*/ +if (unlikely (vmx->loaded_vmcs->hv_timer_soft_disabled)) +return EXIT_FASTPATH_REENTER_GUEST ; + +if (!vmx->req_immediate_exit) {kvm_lapic_expired_hv_timer (vcpu);return EXIT_FASTPATH_REENTER_GUEST ; }
Signature · 1 line
2.43.0.472.g3155946c3a-goog
Sean Christopherson
maintainerPATCH 3/6 KVM: VMX: Handle forced exit due to preemption timer in fastpath
In reply to Sean ChristophersonHandle VMX preemption timer VM-Exits due to KVM forcing an exit in the exit fastpath, i.e. avoid calling back into handle_preemption_timer() for the same exit. There is no work to be done for forced exits, as the name suggests the goal is purely to get control back in KVM.
In addition to shaving a few cycles, this will allow cleanly separating handle_fastpath_preemption_timer() from handle_preemption_timer(), e.g. it's not immediately obvious why _apparently_ calling handle_fastpath_preemption_timer() twice on a "slow" exit is necessary:
the "slow" call is necessary to handle exits from L2, which are excluded from the fastpath by vmx_vcpu_run().
--- arch/x86/kvm/vmx/vmx.c | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-)
arch/x86/kvm/vmx/vmx.c +8 -5
@@ -6003,12 +6003,15 @@ static fastpath_t handle_fastpath_preemption_timer(struct kvm_vcpu *vcpu)if (unlikely (vmx->loaded_vmcs->hv_timer_soft_disabled))return EXIT_FASTPATH_REENTER_GUEST ; -if (!vmx->req_immediate_exit) { -kvm_lapic_expired_hv_timer (vcpu); -return EXIT_FASTPATH_REENTER_GUEST ; - } +/* +* If the timer expired because KVM used it to force an immediate exit, +* then mission accomplished. +*/ +if (vmx->req_immediate_exit) +return EXIT_FASTPATH_EXIT_HANDLED ; -return EXIT_FASTPATH_NONE ; +kvm_lapic_expired_hv_timer (vcpu); +return EXIT_FASTPATH_REENTER_GUEST ; }static int handle_preemption_timer (struct kvm_vcpu *vcpu)
Signature · 1 line
2.43.0.472.g3155946c3a-goog
Sean Christopherson
maintainerPATCH 4/6 KVM: x86: Move handling of is_guest_mode() into fastpath exit handlers
In reply to Sean ChristophersonLet the fastpath code decide which exits can/can't be handled in the fastpath when L2 is active, e.g. when KVM generates a VMX preemption timer exit to forcefully regain control, there is no "work" to be done and so such exits can be handled in the fastpath regardless of whether L1 or L2 is active.
Moving the is_guest_mode() check into the fastpath code also makes it easier to see that L2 isn't allowed to use the fastpath in most cases, e.g. it's not immediately obvious why handle_fastpath_preemption_timer() is called from the fastpath and the normal path.
--- arch/x86/kvm/svm/svm.c | 6 +++--- arch/x86/kvm/vmx/vmx.c | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-)
arch/x86/kvm/svm/svm.c +3 -3
@@ -4092,6 +4092,9 @@ static int svm_vcpu_pre_run(struct kvm_vcpu *vcpu)static fastpath_t svm_exit_handlers_fastpath (struct kvm_vcpu *vcpu) { +if (is_guest_mode (vcpu)) +return EXIT_FASTPATH_NONE ; +if (to_svm (vcpu)->vmcb->control.exit_code ==SVM_EXIT_MSR &&to_svm (vcpu)->vmcb->control.exit_info_1)return handle_fastpath_set_msr_irqoff (vcpu);
@@ -4238,9 +4241,6 @@ static __no_kcsan fastpath_t svm_vcpu_run(struct kvm_vcpu *vcpu,svm_complete_interrupts (vcpu); -if (is_guest_mode (vcpu)) -return EXIT_FASTPATH_NONE ; -return svm_exit_handlers_fastpath (vcpu); }
arch/x86/kvm/vmx/vmx.c +3 -3
@@ -7217,6 +7217,9 @@ void noinstr vmx_spec_ctrl_restore_host(struct vcpu_vmx *vmx,static fastpath_t vmx_exit_handlers_fastpath (struct kvm_vcpu *vcpu) { +if (is_guest_mode (vcpu)) +return EXIT_FASTPATH_NONE ; +switch (to_vmx (vcpu)->exit_reason.basic) {case EXIT_REASON_MSR_WRITE :return handle_fastpath_set_msr_irqoff (vcpu);
@@ -7428,9 +7431,6 @@ static fastpath_t vmx_vcpu_run(struct kvm_vcpu *vcpu, bool force_immediate_exit)vmx_recover_nmi_blocking (vmx);vmx_complete_interrupts (vmx); -if (is_guest_mode (vcpu)) -return EXIT_FASTPATH_NONE ; -return vmx_exit_handlers_fastpath (vcpu); }
Signature · 1 line
2.43.0.472.g3155946c3a-goog
Sean Christopherson
maintainerPATCH 5/6 KVM: VMX: Handle KVM-induced preemption timer exits in fastpath for L2
In reply to Sean ChristophersonEat VMX treemption timer exits in the fastpath regardless of whether L1 or L2 is active. The VM-Exit is 100% KVM-induced, i.e. there is nothing directly related to the exit that KVM needs to do on behalf of the guest, thus there is no reason to wait until the slow path to do nothing.
Opportunistically add comments explaining why preemption timer exits for emulating the guest's APIC timer need to go down the slow path.
--- arch/x86/kvm/vmx/vmx.c | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-)
arch/x86/kvm/vmx/vmx.c +20 -2
@@ -6010,13 +6010,26 @@ static fastpath_t handle_fastpath_preemption_timer(struct kvm_vcpu *vcpu)if (vmx->req_immediate_exit)return EXIT_FASTPATH_EXIT_HANDLED ; +/* +* If L2 is active, go down the slow path as emulating the guest timer +* expiration likely requires synthesizing a nested VM-Exit. +*/ +if (is_guest_mode (vcpu)) +return EXIT_FASTPATH_NONE ; +kvm_lapic_expired_hv_timer (vcpu);return EXIT_FASTPATH_REENTER_GUEST ; }static int handle_preemption_timer (struct kvm_vcpu *vcpu) { -handle_fastpath_preemption_timer (vcpu); +/* +* This non-fastpath handler is reached if and only if the preemption +* timer was being used to emulate a guest timer while L2 is active. +* All other scenarios are supposed to be handled in the fastpath. +*/ +WARN_ON_ONCE (!is_guest_mode (vcpu)); +kvm_lapic_expired_hv_timer (vcpu);return 1 ; }
@@ -7217,7 +7230,12 @@ void noinstr vmx_spec_ctrl_restore_host(struct vcpu_vmx *vmx,static fastpath_t vmx_exit_handlers_fastpath (struct kvm_vcpu *vcpu) { -if (is_guest_mode (vcpu)) +/* +* If L2 is active, some VMX preemption timer exits can be handled in +* the fastpath even, all other exits must use the slow path. +*/ +if (is_guest_mode (vcpu) && +to_vmx (vcpu)->exit_reason.basic !=EXIT_REASON_PREEMPTION_TIMER )return EXIT_FASTPATH_NONE ;switch (to_vmx (vcpu)->exit_reason.basic) {
Signature · 1 line
2.43.0.472.g3155946c3a-goog
Sean Christopherson
maintainerPATCH 6/6 KVM: x86: Fully defer to vendor code to decide how to force immediate exit
In reply to Sean ChristophersonNow that vmx->req_immediate_exit is used only in the scope of vmx_vcpu_run(), use force_immediate_exit to detect that KVM should usurp the VMX preemption to force a VM-Exit and let vendor code fully handle forcing a VM-Exit.
Opportunsitically drop __kvm_request_immediate_exit() and just have vendor code call smp_send_reschedule() directly. SVM already does this when injecting an event while also trying to single-stepp an IRET, i.e. it's not exactly secret knowledge that KVM uses a reschedule IPI to force an exit.
--- arch/x86/include/asm/kvm-x86-ops.h | 1 - arch/x86/include/asm/kvm_host.h | 3 --- arch/x86/kvm/svm/svm.c | 7 ++++--- arch/x86/kvm/vmx/vmx.c | 32 +++++++++++++----------------- arch/x86/kvm/vmx/vmx.h | 2 -- arch/x86/kvm/x86.c | 10 +--------- 6 files changed, 19 insertions(+), 36 deletions(-)
arch/x86/include/asm/kvm-x86-ops.h +0 -1
@@ -103,7 +103,6 @@ KVM_X86_OP(write_tsc_multiplier) KVM_X86_OP(get_exit_info) KVM_X86_OP(check_intercept) KVM_X86_OP(handle_exit_irqoff) -KVM_X86_OP(request_immediate_exit) KVM_X86_OP(sched_in) KVM_X86_OP_OPTIONAL(update_cpu_dirty_logging) KVM_X86_OP_OPTIONAL(vcpu_blocking)
arch/x86/include/asm/kvm_host.h +0 -3
@@ -1732,8 +1732,6 @@ struct kvm_x86_ops { struct x86_exception *exception);void (*handle_exit_irqoff)(struct kvm_vcpu *vcpu); -void (*request_immediate_exit)(struct kvm_vcpu *vcpu); -void (*sched_in)(struct kvm_vcpu *vcpu,int cpu);/*
@@ -2239,7 +2237,6 @@ extern bool kvm_find_async_pf_gfn(struct kvm_vcpu *vcpu, gfn_t gfn);int kvm_skip_emulated_instruction (struct kvm_vcpu *vcpu);int kvm_complete_insn_gp (struct kvm_vcpu *vcpu,int err); -void __kvm_request_immediate_exit (struct kvm_vcpu *vcpu);void __user *__x86_set_memory_region (struct kvm *kvm,int id,gpa_t gpa,u32 size);
arch/x86/kvm/svm/svm.c +4 -3
@@ -4143,8 +4143,11 @@ static __no_kcsan fastpath_t svm_vcpu_run(struct kvm_vcpu *vcpu,* is enough to force an immediate vmexit. */ disable_nmi_singlestep (svm); + force_immediate_exit = true; + } + +if (force_immediate_exit)smp_send_reschedule (vcpu->cpu); - }pre_svm_run (vcpu);
@@ -4998,8 +5001,6 @@ static struct kvm_x86_ops svm_x86_ops __initdata = { .check_intercept = svm_check_intercept, .handle_exit_irqoff = svm_handle_exit_irqoff, - .request_immediate_exit = __kvm_request_immediate_exit, - .sched_in = svm_sched_in, .nested_ops = &svm_nested_ops,
arch/x86/kvm/vmx/vmx.c +14 -18
@@ -49,6 +49,8 @@#include <asm/spec-ctrl.h> #include <asm/vmx.h> +#include <trace/events/ipi.h> +#include "capabilities.h" #include "cpuid.h" #include "hyperv.h"
@@ -1281,8 +1283,6 @@ void vmx_prepare_switch_to_guest(struct kvm_vcpu *vcpu)u16 fs_sel, gs_sel;int i; - vmx->req_immediate_exit = false; -/* * Note that guest MSRs to be saved/restored can also be changed * when guest state is loaded. This happens when guest transitions
@@ -5991,7 +5991,8 @@ static int handle_pml_full(struct kvm_vcpu *vcpu)return 1 ; } -static fastpath_t handle_fastpath_preemption_timer (struct kvm_vcpu *vcpu) +static fastpath_t handle_fastpath_preemption_timer (struct kvm_vcpu *vcpu, +bool force_immediate_exit) {struct vcpu_vmx *vmx =to_vmx (vcpu);
@@ -6007,7 +6008,7 @@ static fastpath_t handle_fastpath_preemption_timer(struct kvm_vcpu *vcpu)* If the timer expired because KVM used it to force an immediate exit, * then mission accomplished. */ -if (vmx->req_immediate_exit) +if (force_immediate_exit)return EXIT_FASTPATH_EXIT_HANDLED ;/*
@@ -7169,13 +7170,13 @@ static void atomic_switch_perf_msrs(struct vcpu_vmx *vmx) msrs[i].host, false); } -static void vmx_update_hv_timer (struct kvm_vcpu *vcpu) +static void vmx_update_hv_timer (struct kvm_vcpu *vcpu,bool force_immediate_exit) {struct vcpu_vmx *vmx =to_vmx (vcpu);u64 tscl;u32 delta_tsc; -if (vmx->req_immediate_exit) { +if (force_immediate_exit) {vmcs_write32 (VMX_PREEMPTION_TIMER_VALUE ,0 ); vmx->loaded_vmcs->hv_timer_soft_disabled = false; }else if (vmx->hv_deadline_tsc !=-1 ) {
@@ -7228,7 +7229,8 @@ void noinstr vmx_spec_ctrl_restore_host(struct vcpu_vmx *vmx,barrier_nospec (); } -static fastpath_t vmx_exit_handlers_fastpath (struct kvm_vcpu *vcpu) +static fastpath_t vmx_exit_handlers_fastpath (struct kvm_vcpu *vcpu, +bool force_immediate_exit) {/* * If L2 is active, some VMX preemption timer exits can be handled in
@@ -7242,7 +7244,7 @@ static fastpath_t vmx_exit_handlers_fastpath(struct kvm_vcpu *vcpu)case EXIT_REASON_MSR_WRITE :return handle_fastpath_set_msr_irqoff (vcpu);case EXIT_REASON_PREEMPTION_TIMER : -return handle_fastpath_preemption_timer (vcpu); +return handle_fastpath_preemption_timer (vcpu, force_immediate_exit);default :return EXIT_FASTPATH_NONE ; }
@@ -7385,7 +7387,9 @@ static fastpath_t vmx_vcpu_run(struct kvm_vcpu *vcpu, bool force_immediate_exit)vmx_passthrough_lbr_msrs (vcpu);if (enable_preemption_timer) -vmx_update_hv_timer (vcpu); +vmx_update_hv_timer (vcpu, force_immediate_exit); +else if (force_immediate_exit) +smp_send_reschedule (vcpu->cpu);kvm_wait_lapic_expire (vcpu);
@@ -7449,7 +7453,7 @@ static fastpath_t vmx_vcpu_run(struct kvm_vcpu *vcpu, bool force_immediate_exit)vmx_recover_nmi_blocking (vmx);vmx_complete_interrupts (vmx); -return vmx_exit_handlers_fastpath (vcpu); +return vmx_exit_handlers_fastpath (vcpu, force_immediate_exit); }static void vmx_vcpu_free (struct kvm_vcpu *vcpu)
@@ -7929,11 +7933,6 @@ static __init void vmx_set_cpu_caps(void)kvm_cpu_cap_check_and_set (X86_FEATURE_WAITPKG ); } -static void vmx_request_immediate_exit (struct kvm_vcpu *vcpu) -{ -to_vmx (vcpu)->req_immediate_exit = true; -} -static int vmx_check_intercept_io (struct kvm_vcpu *vcpu,struct x86_instruction_info *info) {
@@ -8386,8 +8385,6 @@ static struct kvm_x86_ops vmx_x86_ops __initdata = { .check_intercept = vmx_check_intercept, .handle_exit_irqoff = vmx_handle_exit_irqoff, - .request_immediate_exit = vmx_request_immediate_exit, - .sched_in = vmx_sched_in, .cpu_dirty_log_size = PML_ENTITY_NUM,
@@ -8647,7 +8644,6 @@ static __init int hardware_setup(void)if (!enable_preemption_timer) { vmx_x86_ops.set_hv_timer =NULL ; vmx_x86_ops.cancel_hv_timer =NULL ; - vmx_x86_ops.request_immediate_exit = __kvm_request_immediate_exit; } kvm_caps.supported_mce_cap |=MCG_LMCE_P ;
arch/x86/kvm/vmx/vmx.h +0 -2
@@ -332,8 +332,6 @@ struct vcpu_vmx {unsigned int ple_window;bool ple_window_dirty; -bool req_immediate_exit; -/* Support for PML */ #define PML_ENTITY_NUM 512struct page *pml_pg;
arch/x86/kvm/x86.c +1 -9
@@ -10673,12 +10673,6 @@ static void kvm_vcpu_reload_apic_access_page(struct kvm_vcpu *vcpu)static_call_cond (kvm_x86_set_apic_access_page_addr)(vcpu); } -void __kvm_request_immediate_exit (struct kvm_vcpu *vcpu) -{ -smp_send_reschedule (vcpu->cpu); -} -EXPORT_SYMBOL_GPL (__kvm_request_immediate_exit); -/* * Called within kvm->srcu read side. * Returns 1 to let vcpu_run() continue the guest execution loop without
@@ -10928,10 +10922,8 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) goto cancel_injection; } -if (req_immediate_exit) { +if (req_immediate_exit)kvm_make_request (KVM_REQ_EVENT , vcpu); -static_call (kvm_x86_request_immediate_exit)(vcpu); - }fpregs_assert_state_consistent ();if (test_thread_flag (TIF_NEED_FPU_LOAD ))
Signature · 1 line
2.43.0.472.g3155946c3a-goog
Quoted 16 lines · Sean Christopherson
Plumb "
force_immediate_exit" into thekvm_entry()tracepoint, as suggested by Maxim, and then follow that up with cleanups that are made possible by havingforce_immediate_exitmade available to .vcpu_run(), e.g. VMX can use the on-stack param instead of what is effectively a temporary field invcpu_vmx.Sean Christopherson (6):
KVM: x86: Plumb "force_immediate_exit" intokvm_entry()tracepoint
KVM: VMX: Re-enter guest in fastpath for "spurious" preemption timer
exits
KVM: VMX: Handle forced exit due to preemption timer in fastpath
KVM: x86: Move handling ofis_guest_mode()into fastpath exit handlers
KVM: VMX: Handle KVM-induced preemption timer exits in fastpath for L2
KVM: x86: Fully defer to vendor code to decide how to force immediate
exit
Quoted 1 line
[...]
Applied to kvm-x86 misc, thanks!
[1/6] KVM: x86: Plumb "force_immediate_exit" into kvm_entry() tracepoint
https://github.com/kvm-x86/linux/commit/9c9025ea003a [2/6] KVM: VMX: Re-enter guest in fastpath for "spurious" preemption timer exits https://github.com/kvm-x86/linux/commit/e6b5d16bbd2d [3/6] KVM: VMX: Handle forced exit due to preemption timer in fastpath https://github.com/kvm-x86/linux/commit/11776aa0cfa7 [4/6] KVM: x86: Move handling of is_guest_mode() into fastpath exit handlers https://github.com/kvm-x86/linux/commit/bf1a49436ea3 [5/6] KVM: VMX: Handle KVM-induced preemption timer exits in fastpath for L2 https://github.com/kvm-x86/linux/commit/7b3d1bbf8d68 [6/6] KVM: x86: Fully defer to vendor code to decide how to force immediate exit https://github.com/kvm-x86/linux/commit/0ec3d6d1f169