lkml.org 
[lkml]   [2017]   [May]   [18]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 4.11 029/114] Revert "KVM: Support vCPU-based gfn->hva cache"
    Date
    4.11-stable review patch.  If anyone has any objections, please let me know.

    ------------------

    From: Paolo Bonzini <pbonzini@redhat.com>

    commit 4e335d9e7ddbcf83d03e7fbe65797ebed2272c18 upstream.

    This reverts commit bbd6411513aa8ef3ea02abab61318daf87c1af1e.

    I've been sitting on this revert for too long and it unfortunately
    missed 4.11. It's also the reason why I haven't merged ring-based
    dirty tracking for 4.12.

    Using kvm_vcpu_memslots in kvm_gfn_to_hva_cache_init and
    kvm_vcpu_write_guest_offset_cached means that the MSR value can
    now be used to access SMRAM, simply by making it point to an SMRAM
    physical address. This is problematic because it lets the guest
    OS overwrite memory that it shouldn't be able to touch.

    Fixes: bbd6411513aa8ef3ea02abab61318daf87c1af1e
    Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

    ---
    arch/x86/kvm/lapic.c | 22 ++++++++++++----------
    arch/x86/kvm/x86.c | 41 +++++++++++++++++++++--------------------
    include/linux/kvm_host.h | 16 ++++++++--------
    virt/kvm/kvm_main.c | 34 +++++++++++++++++-----------------
    4 files changed, 58 insertions(+), 55 deletions(-)

    --- a/arch/x86/kvm/lapic.c
    +++ b/arch/x86/kvm/lapic.c
    @@ -529,14 +529,16 @@ int kvm_apic_set_irq(struct kvm_vcpu *vc

    static int pv_eoi_put_user(struct kvm_vcpu *vcpu, u8 val)
    {
    - return kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.pv_eoi.data, &val,
    - sizeof(val));
    +
    + return kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.pv_eoi.data, &val,
    + sizeof(val));
    }

    static int pv_eoi_get_user(struct kvm_vcpu *vcpu, u8 *val)
    {
    - return kvm_vcpu_read_guest_cached(vcpu, &vcpu->arch.pv_eoi.data, val,
    - sizeof(*val));
    +
    + return kvm_read_guest_cached(vcpu->kvm, &vcpu->arch.pv_eoi.data, val,
    + sizeof(*val));
    }

    static inline bool pv_eoi_enabled(struct kvm_vcpu *vcpu)
    @@ -2285,8 +2287,8 @@ void kvm_lapic_sync_from_vapic(struct kv
    if (!test_bit(KVM_APIC_CHECK_VAPIC, &vcpu->arch.apic_attention))
    return;

    - if (kvm_vcpu_read_guest_cached(vcpu, &vcpu->arch.apic->vapic_cache, &data,
    - sizeof(u32)))
    + if (kvm_read_guest_cached(vcpu->kvm, &vcpu->arch.apic->vapic_cache, &data,
    + sizeof(u32)))
    return;

    apic_set_tpr(vcpu->arch.apic, data & 0xff);
    @@ -2338,14 +2340,14 @@ void kvm_lapic_sync_to_vapic(struct kvm_
    max_isr = 0;
    data = (tpr & 0xff) | ((max_isr & 0xf0) << 8) | (max_irr << 24);

    - kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.apic->vapic_cache, &data,
    - sizeof(u32));
    + kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.apic->vapic_cache, &data,
    + sizeof(u32));
    }

    int kvm_lapic_set_vapic_addr(struct kvm_vcpu *vcpu, gpa_t vapic_addr)
    {
    if (vapic_addr) {
    - if (kvm_vcpu_gfn_to_hva_cache_init(vcpu,
    + if (kvm_gfn_to_hva_cache_init(vcpu->kvm,
    &vcpu->arch.apic->vapic_cache,
    vapic_addr, sizeof(u32)))
    return -EINVAL;
    @@ -2439,7 +2441,7 @@ int kvm_lapic_enable_pv_eoi(struct kvm_v
    vcpu->arch.pv_eoi.msr_val = data;
    if (!pv_eoi_enabled(vcpu))
    return 0;
    - return kvm_vcpu_gfn_to_hva_cache_init(vcpu, &vcpu->arch.pv_eoi.data,
    + return kvm_gfn_to_hva_cache_init(vcpu->kvm, &vcpu->arch.pv_eoi.data,
    addr, sizeof(u8));
    }

    --- a/arch/x86/kvm/x86.c
    +++ b/arch/x86/kvm/x86.c
    @@ -1813,7 +1813,7 @@ static void kvm_setup_pvclock_page(struc
    struct kvm_vcpu_arch *vcpu = &v->arch;
    struct pvclock_vcpu_time_info guest_hv_clock;

    - if (unlikely(kvm_vcpu_read_guest_cached(v, &vcpu->pv_time,
    + if (unlikely(kvm_read_guest_cached(v->kvm, &vcpu->pv_time,
    &guest_hv_clock, sizeof(guest_hv_clock))))
    return;

    @@ -1834,9 +1834,9 @@ static void kvm_setup_pvclock_page(struc
    BUILD_BUG_ON(offsetof(struct pvclock_vcpu_time_info, version) != 0);

    vcpu->hv_clock.version = guest_hv_clock.version + 1;
    - kvm_vcpu_write_guest_cached(v, &vcpu->pv_time,
    - &vcpu->hv_clock,
    - sizeof(vcpu->hv_clock.version));
    + kvm_write_guest_cached(v->kvm, &vcpu->pv_time,
    + &vcpu->hv_clock,
    + sizeof(vcpu->hv_clock.version));

    smp_wmb();

    @@ -1850,16 +1850,16 @@ static void kvm_setup_pvclock_page(struc

    trace_kvm_pvclock_update(v->vcpu_id, &vcpu->hv_clock);

    - kvm_vcpu_write_guest_cached(v, &vcpu->pv_time,
    - &vcpu->hv_clock,
    - sizeof(vcpu->hv_clock));
    + kvm_write_guest_cached(v->kvm, &vcpu->pv_time,
    + &vcpu->hv_clock,
    + sizeof(vcpu->hv_clock));

    smp_wmb();

    vcpu->hv_clock.version++;
    - kvm_vcpu_write_guest_cached(v, &vcpu->pv_time,
    - &vcpu->hv_clock,
    - sizeof(vcpu->hv_clock.version));
    + kvm_write_guest_cached(v->kvm, &vcpu->pv_time,
    + &vcpu->hv_clock,
    + sizeof(vcpu->hv_clock.version));
    }

    static int kvm_guest_time_update(struct kvm_vcpu *v)
    @@ -2092,7 +2092,7 @@ static int kvm_pv_enable_async_pf(struct
    return 0;
    }

    - if (kvm_vcpu_gfn_to_hva_cache_init(vcpu, &vcpu->arch.apf.data, gpa,
    + if (kvm_gfn_to_hva_cache_init(vcpu->kvm, &vcpu->arch.apf.data, gpa,
    sizeof(u32)))
    return 1;

    @@ -2111,7 +2111,7 @@ static void record_steal_time(struct kvm
    if (!(vcpu->arch.st.msr_val & KVM_MSR_ENABLED))
    return;

    - if (unlikely(kvm_vcpu_read_guest_cached(vcpu, &vcpu->arch.st.stime,
    + if (unlikely(kvm_read_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,
    &vcpu->arch.st.steal, sizeof(struct kvm_steal_time))))
    return;

    @@ -2122,7 +2122,7 @@ static void record_steal_time(struct kvm

    vcpu->arch.st.steal.version += 1;

    - kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.st.stime,
    + kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,
    &vcpu->arch.st.steal, sizeof(struct kvm_steal_time));

    smp_wmb();
    @@ -2131,14 +2131,14 @@ static void record_steal_time(struct kvm
    vcpu->arch.st.last_steal;
    vcpu->arch.st.last_steal = current->sched_info.run_delay;

    - kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.st.stime,
    + kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,
    &vcpu->arch.st.steal, sizeof(struct kvm_steal_time));

    smp_wmb();

    vcpu->arch.st.steal.version += 1;

    - kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.st.stime,
    + kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,
    &vcpu->arch.st.steal, sizeof(struct kvm_steal_time));
    }

    @@ -2243,7 +2243,7 @@ int kvm_set_msr_common(struct kvm_vcpu *
    if (!(data & 1))
    break;

    - if (kvm_vcpu_gfn_to_hva_cache_init(vcpu,
    + if (kvm_gfn_to_hva_cache_init(vcpu->kvm,
    &vcpu->arch.pv_time, data & ~1ULL,
    sizeof(struct pvclock_vcpu_time_info)))
    vcpu->arch.pv_time_enabled = false;
    @@ -2264,7 +2264,7 @@ int kvm_set_msr_common(struct kvm_vcpu *
    if (data & KVM_STEAL_RESERVED_MASK)
    return 1;

    - if (kvm_vcpu_gfn_to_hva_cache_init(vcpu, &vcpu->arch.st.stime,
    + if (kvm_gfn_to_hva_cache_init(vcpu->kvm, &vcpu->arch.st.stime,
    data & KVM_STEAL_VALID_BITS,
    sizeof(struct kvm_steal_time)))
    return 1;
    @@ -2878,7 +2878,7 @@ static void kvm_steal_time_set_preempted

    vcpu->arch.st.steal.preempted = 1;

    - kvm_vcpu_write_guest_offset_cached(vcpu, &vcpu->arch.st.stime,
    + kvm_write_guest_offset_cached(vcpu->kvm, &vcpu->arch.st.stime,
    &vcpu->arch.st.steal.preempted,
    offsetof(struct kvm_steal_time, preempted),
    sizeof(vcpu->arch.st.steal.preempted));
    @@ -8548,8 +8548,9 @@ static void kvm_del_async_pf_gfn(struct

    static int apf_put_user(struct kvm_vcpu *vcpu, u32 val)
    {
    - return kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.apf.data, &val,
    - sizeof(val));
    +
    + return kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.apf.data, &val,
    + sizeof(val));
    }

    void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
    --- a/include/linux/kvm_host.h
    +++ b/include/linux/kvm_host.h
    @@ -641,18 +641,18 @@ int kvm_read_guest_page(struct kvm *kvm,
    int kvm_read_guest_atomic(struct kvm *kvm, gpa_t gpa, void *data,
    unsigned long len);
    int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);
    -int kvm_vcpu_read_guest_cached(struct kvm_vcpu *vcpu, struct gfn_to_hva_cache *ghc,
    - void *data, unsigned long len);
    +int kvm_read_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
    + void *data, unsigned long len);
    int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
    int offset, int len);
    int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
    unsigned long len);
    -int kvm_vcpu_write_guest_cached(struct kvm_vcpu *v, struct gfn_to_hva_cache *ghc,
    - void *data, unsigned long len);
    -int kvm_vcpu_write_guest_offset_cached(struct kvm_vcpu *v, struct gfn_to_hva_cache *ghc,
    - void *data, int offset, unsigned long len);
    -int kvm_vcpu_gfn_to_hva_cache_init(struct kvm_vcpu *v, struct gfn_to_hva_cache *ghc,
    - gpa_t gpa, unsigned long len);
    +int kvm_write_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
    + void *data, unsigned long len);
    +int kvm_write_guest_offset_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
    + void *data, int offset, unsigned long len);
    +int kvm_gfn_to_hva_cache_init(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
    + gpa_t gpa, unsigned long len);
    int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
    int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
    struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
    --- a/virt/kvm/kvm_main.c
    +++ b/virt/kvm/kvm_main.c
    @@ -1973,18 +1973,18 @@ static int __kvm_gfn_to_hva_cache_init(s
    return 0;
    }

    -int kvm_vcpu_gfn_to_hva_cache_init(struct kvm_vcpu *vcpu, struct gfn_to_hva_cache *ghc,
    +int kvm_gfn_to_hva_cache_init(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
    gpa_t gpa, unsigned long len)
    {
    - struct kvm_memslots *slots = kvm_vcpu_memslots(vcpu);
    + struct kvm_memslots *slots = kvm_memslots(kvm);
    return __kvm_gfn_to_hva_cache_init(slots, ghc, gpa, len);
    }
    -EXPORT_SYMBOL_GPL(kvm_vcpu_gfn_to_hva_cache_init);
    +EXPORT_SYMBOL_GPL(kvm_gfn_to_hva_cache_init);

    -int kvm_vcpu_write_guest_offset_cached(struct kvm_vcpu *vcpu, struct gfn_to_hva_cache *ghc,
    - void *data, int offset, unsigned long len)
    +int kvm_write_guest_offset_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
    + void *data, int offset, unsigned long len)
    {
    - struct kvm_memslots *slots = kvm_vcpu_memslots(vcpu);
    + struct kvm_memslots *slots = kvm_memslots(kvm);
    int r;
    gpa_t gpa = ghc->gpa + offset;

    @@ -1994,7 +1994,7 @@ int kvm_vcpu_write_guest_offset_cached(s
    __kvm_gfn_to_hva_cache_init(slots, ghc, ghc->gpa, ghc->len);

    if (unlikely(!ghc->memslot))
    - return kvm_vcpu_write_guest(vcpu, gpa, data, len);
    + return kvm_write_guest(kvm, gpa, data, len);

    if (kvm_is_error_hva(ghc->hva))
    return -EFAULT;
    @@ -2006,19 +2006,19 @@ int kvm_vcpu_write_guest_offset_cached(s

    return 0;
    }
    -EXPORT_SYMBOL_GPL(kvm_vcpu_write_guest_offset_cached);
    +EXPORT_SYMBOL_GPL(kvm_write_guest_offset_cached);

    -int kvm_vcpu_write_guest_cached(struct kvm_vcpu *vcpu, struct gfn_to_hva_cache *ghc,
    - void *data, unsigned long len)
    +int kvm_write_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
    + void *data, unsigned long len)
    {
    - return kvm_vcpu_write_guest_offset_cached(vcpu, ghc, data, 0, len);
    + return kvm_write_guest_offset_cached(kvm, ghc, data, 0, len);
    }
    -EXPORT_SYMBOL_GPL(kvm_vcpu_write_guest_cached);
    +EXPORT_SYMBOL_GPL(kvm_write_guest_cached);

    -int kvm_vcpu_read_guest_cached(struct kvm_vcpu *vcpu, struct gfn_to_hva_cache *ghc,
    - void *data, unsigned long len)
    +int kvm_read_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
    + void *data, unsigned long len)
    {
    - struct kvm_memslots *slots = kvm_vcpu_memslots(vcpu);
    + struct kvm_memslots *slots = kvm_memslots(kvm);
    int r;

    BUG_ON(len > ghc->len);
    @@ -2027,7 +2027,7 @@ int kvm_vcpu_read_guest_cached(struct kv
    __kvm_gfn_to_hva_cache_init(slots, ghc, ghc->gpa, ghc->len);

    if (unlikely(!ghc->memslot))
    - return kvm_vcpu_read_guest(vcpu, ghc->gpa, data, len);
    + return kvm_read_guest(kvm, ghc->gpa, data, len);

    if (kvm_is_error_hva(ghc->hva))
    return -EFAULT;
    @@ -2038,7 +2038,7 @@ int kvm_vcpu_read_guest_cached(struct kv

    return 0;
    }
    -EXPORT_SYMBOL_GPL(kvm_vcpu_read_guest_cached);
    +EXPORT_SYMBOL_GPL(kvm_read_guest_cached);

    int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len)
    {

    \
     
     \ /
      Last update: 2017-05-18 14:12    [W:3.019 / U:0.032 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site