lkml.org 
[lkml]   [2022]   [May]   [1]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v3 06/12] KVM: SVM: Re-inject INTn instead of retrying the insn on "failure"
    Date
    From: Sean Christopherson <seanjc@google.com>

    Re-inject INTn software interrupts instead of retrying the instruction if
    the CPU encountered an intercepted exception while vectoring the INTn,
    e.g. if KVM intercepted a #PF when utilizing shadow paging. Retrying the
    instruction is architecturally wrong e.g. will result in a spurious #DB
    if there's a code breakpoint on the INT3/O, and lack of re-injection also
    breaks nested virtualization, e.g. if L1 injects a software interrupt and
    vectoring the injected interrupt encounters an exception that is
    intercepted by L0 but not L1.

    Signed-off-by: Sean Christopherson <seanjc@google.com>
    Signed-off-by: Maciej S. Szmigiero <maciej.szmigiero@oracle.com>
    ---
    arch/x86/kvm/svm/nested.c | 7 +++----
    arch/x86/kvm/svm/svm.c | 23 +++++++++++++++++++----
    2 files changed, 22 insertions(+), 8 deletions(-)

    diff --git a/arch/x86/kvm/svm/nested.c b/arch/x86/kvm/svm/nested.c
    index 0163238aa198..a83e367ade54 100644
    --- a/arch/x86/kvm/svm/nested.c
    +++ b/arch/x86/kvm/svm/nested.c
    @@ -617,10 +617,9 @@ static inline bool is_evtinj_soft(u32 evtinj)
    if (!(evtinj & SVM_EVTINJ_VALID))
    return false;

    - /*
    - * Intentionally return false for SOFT events, SVM doesn't yet support
    - * re-injecting soft interrupts.
    - */
    + if (type == SVM_EVTINJ_TYPE_SOFT)
    + return true;
    +
    return type == SVM_EVTINJ_TYPE_EXEPT && kvm_exception_is_soft(vector);
    }

    diff --git a/arch/x86/kvm/svm/svm.c b/arch/x86/kvm/svm/svm.c
    index 94d111ddec1c..a1158fc25c4c 100644
    --- a/arch/x86/kvm/svm/svm.c
    +++ b/arch/x86/kvm/svm/svm.c
    @@ -3430,12 +3430,22 @@ static void svm_inject_nmi(struct kvm_vcpu *vcpu)
    static void svm_inject_irq(struct kvm_vcpu *vcpu)
    {
    struct vcpu_svm *svm = to_svm(vcpu);
    + u32 type;
    +
    + if (vcpu->arch.interrupt.soft) {
    + if (svm_update_soft_interrupt_rip(vcpu))
    + return;
    +
    + type = SVM_EVTINJ_TYPE_SOFT;
    + } else {
    + type = SVM_EVTINJ_TYPE_INTR;
    + }

    trace_kvm_inj_virq(vcpu->arch.interrupt.nr);
    ++vcpu->stat.irq_injections;

    svm->vmcb->control.event_inj = vcpu->arch.interrupt.nr |
    - SVM_EVTINJ_VALID | SVM_EVTINJ_TYPE_INTR;
    + SVM_EVTINJ_VALID | type;
    }

    void svm_complete_interrupt_delivery(struct kvm_vcpu *vcpu, int delivery_mode,
    @@ -3715,6 +3725,8 @@ static inline void sync_lapic_to_cr8(struct kvm_vcpu *vcpu)
    static void svm_complete_soft_interrupt(struct kvm_vcpu *vcpu, u8 vector,
    int type)
    {
    + bool is_exception = (type == SVM_EXITINTINFO_TYPE_EXEPT);
    + bool is_soft = (type == SVM_EXITINTINFO_TYPE_SOFT);
    struct vcpu_svm *svm = to_svm(vcpu);

    /*
    @@ -3726,8 +3738,7 @@ static void svm_complete_soft_interrupt(struct kvm_vcpu *vcpu, u8 vector,
    * the same event, i.e. if the event is a soft exception/interrupt,
    * otherwise next_rip is unused on VMRUN.
    */
    - if (nrips && type == SVM_EXITINTINFO_TYPE_EXEPT &&
    - kvm_exception_is_soft(vector) &&
    + if (nrips && (is_soft || (is_exception && kvm_exception_is_soft(vector))) &&
    kvm_is_linear_rip(vcpu, svm->soft_int_old_rip + svm->soft_int_csbase))
    svm->vmcb->control.next_rip = svm->soft_int_next_rip;
    /*
    @@ -3738,7 +3749,7 @@ static void svm_complete_soft_interrupt(struct kvm_vcpu *vcpu, u8 vector,
    * hit a #NP in the guest, and the #NP encountered a #PF, the #NP will
    * be the reported vectored event, but RIP still needs to be unwound.
    */
    - else if (!nrips && type == SVM_EXITINTINFO_TYPE_EXEPT &&
    + else if (!nrips && (is_soft || is_exception) &&
    kvm_is_linear_rip(vcpu, svm->soft_int_next_rip + svm->soft_int_csbase))
    kvm_rip_write(vcpu, svm->soft_int_old_rip);
    }
    @@ -3800,9 +3811,13 @@ static void svm_complete_interrupts(struct kvm_vcpu *vcpu)
    case SVM_EXITINTINFO_TYPE_INTR:
    kvm_queue_interrupt(vcpu, vector, false);
    break;
    + case SVM_EXITINTINFO_TYPE_SOFT:
    + kvm_queue_interrupt(vcpu, vector, true);
    + break;
    default:
    break;
    }
    +
    }

    static void svm_cancel_injection(struct kvm_vcpu *vcpu)
    \
     
     \ /
      Last update: 2022-05-02 00:09    [W:2.734 / U:0.032 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site