Commit 97fcc07b authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm 

Pull kvm fixes from Paolo Bonzini:
 "Mostly bugfixes; plus, support for XMM arguments to Hyper-V hypercalls
  now obeys KVM_CAP_HYPERV_ENFORCE_CPUID.

  Both the XMM arguments feature and KVM_CAP_HYPERV_ENFORCE_CPUID are
  new in 5.14, and each did not know of the other"

* tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm:
  KVM: x86/mmu: Fix per-cpu counter corruption on 32-bit builds
  KVM: selftests: fix hyperv_clock test
  KVM: SVM: improve the code readability for ASID management
  KVM: SVM: Fix off-by-one indexing when nullifying last used SEV VMCB
  KVM: Do not leak memory for duplicate debugfs directories
  KVM: selftests: Test access to XMM fast hypercalls
  KVM: x86: hyper-v: Check if guest is allowed to use XMM registers for hypercall input
  KVM: x86: Introduce trace_kvm_hv_hypercall_done()
  KVM: x86: hyper-v: Check access to hypercall before reading XMM registers
  KVM: x86: accept userspace interrupt only if no event is injected
parents 611ffd8a d5aaad6f

arch/x86/kvm/hyperv.c

+14 −4
Original line number Diff line number Diff line
@@ -2016,6 +2016,7 @@ static void kvm_hv_hypercall_set_result(struct kvm_vcpu *vcpu, u64 result) 


static int kvm_hv_hypercall_complete(struct kvm_vcpu *vcpu, u64 result)

{

	trace_kvm_hv_hypercall_done(result);

	kvm_hv_hypercall_set_result(vcpu, result);

	++vcpu->stat.hypercalls;

	return kvm_skip_emulated_instruction(vcpu);
@@ -2139,6 +2140,7 @@ static bool hv_check_hypercall_access(struct kvm_vcpu_hv *hv_vcpu, u16 code) 


int kvm_hv_hypercall(struct kvm_vcpu *vcpu)

{

	struct kvm_vcpu_hv *hv_vcpu = to_hv_vcpu(vcpu);

	struct kvm_hv_hcall hc;

	u64 ret = HV_STATUS_SUCCESS;
@@ -2173,17 +2175,25 @@ int kvm_hv_hypercall(struct kvm_vcpu *vcpu) 
	hc.rep_idx = (hc.param >> HV_HYPERCALL_REP_START_OFFSET) & 0xfff;

	hc.rep = !!(hc.rep_cnt || hc.rep_idx);



	if (hc.fast && is_xmm_fast_hypercall(&hc))

		kvm_hv_hypercall_read_xmm(&hc);



	trace_kvm_hv_hypercall(hc.code, hc.fast, hc.rep_cnt, hc.rep_idx,

			       hc.ingpa, hc.outgpa);



	if (unlikely(!hv_check_hypercall_access(to_hv_vcpu(vcpu), hc.code))) {

	if (unlikely(!hv_check_hypercall_access(hv_vcpu, hc.code))) {

		ret = HV_STATUS_ACCESS_DENIED;

		goto hypercall_complete;

	}



	if (hc.fast && is_xmm_fast_hypercall(&hc)) {

		if (unlikely(hv_vcpu->enforce_cpuid &&

			     !(hv_vcpu->cpuid_cache.features_edx &

			       HV_X64_HYPERCALL_XMM_INPUT_AVAILABLE))) {

			kvm_queue_exception(vcpu, UD_VECTOR);

			return 1;

		}



		kvm_hv_hypercall_read_xmm(&hc);

	}



	switch (hc.code) {

	case HVCALL_NOTIFY_LONG_SPIN_WAIT:

		if (unlikely(hc.rep)) {

arch/x86/kvm/mmu/mmu.c

+1 −1
Original line number Diff line number Diff line
@@ -1644,7 +1644,7 @@ static int is_empty_shadow_page(u64 *spt) 
 * aggregate version in order to make the slab shrinker

 * faster

 */

static inline void kvm_mod_used_mmu_pages(struct kvm *kvm, unsigned long nr)

static inline void kvm_mod_used_mmu_pages(struct kvm *kvm, long nr)

{

	kvm->arch.n_used_mmu_pages += nr;

	percpu_counter_add(&kvm_total_used_mmu_pages, nr);

arch/x86/kvm/svm/sev.c

+25 −20
Original line number Diff line number Diff line
@@ -64,6 +64,7 @@ static DEFINE_MUTEX(sev_bitmap_lock); 
unsigned int max_sev_asid;

static unsigned int min_sev_asid;

static unsigned long sev_me_mask;

static unsigned int nr_asids;

static unsigned long *sev_asid_bitmap;

static unsigned long *sev_reclaim_asid_bitmap;
@@ -78,11 +79,11 @@ struct enc_region { 
/* Called with the sev_bitmap_lock held, or on shutdown  */

static int sev_flush_asids(int min_asid, int max_asid)

{

	int ret, pos, error = 0;

	int ret, asid, error = 0;



	/* Check if there are any ASIDs to reclaim before performing a flush */

	pos = find_next_bit(sev_reclaim_asid_bitmap, max_asid, min_asid);

	if (pos >= max_asid)

	asid = find_next_bit(sev_reclaim_asid_bitmap, nr_asids, min_asid);

	if (asid > max_asid)

		return -EBUSY;



	/*
@@ -115,15 +116,15 @@ static bool __sev_recycle_asids(int min_asid, int max_asid) 


	/* The flush process will flush all reclaimable SEV and SEV-ES ASIDs */

	bitmap_xor(sev_asid_bitmap, sev_asid_bitmap, sev_reclaim_asid_bitmap,

		   max_sev_asid);

	bitmap_zero(sev_reclaim_asid_bitmap, max_sev_asid);

		   nr_asids);

	bitmap_zero(sev_reclaim_asid_bitmap, nr_asids);



	return true;

}



static int sev_asid_new(struct kvm_sev_info *sev)

{

	int pos, min_asid, max_asid, ret;

	int asid, min_asid, max_asid, ret;

	bool retry = true;

	enum misc_res_type type;
@@ -143,11 +144,11 @@ static int sev_asid_new(struct kvm_sev_info *sev) 
	 * SEV-enabled guests must use asid from min_sev_asid to max_sev_asid.

	 * SEV-ES-enabled guest can use from 1 to min_sev_asid - 1.

	 */

	min_asid = sev->es_active ? 0 : min_sev_asid - 1;

	min_asid = sev->es_active ? 1 : min_sev_asid;

	max_asid = sev->es_active ? min_sev_asid - 1 : max_sev_asid;

again:

	pos = find_next_zero_bit(sev_asid_bitmap, max_sev_asid, min_asid);

	if (pos >= max_asid) {

	asid = find_next_zero_bit(sev_asid_bitmap, max_asid + 1, min_asid);

	if (asid > max_asid) {

		if (retry && __sev_recycle_asids(min_asid, max_asid)) {

			retry = false;

			goto again;
@@ -157,11 +158,11 @@ static int sev_asid_new(struct kvm_sev_info *sev) 
		goto e_uncharge;

	}



	__set_bit(pos, sev_asid_bitmap);

	__set_bit(asid, sev_asid_bitmap);



	mutex_unlock(&sev_bitmap_lock);



	return pos + 1;

	return asid;

e_uncharge:

	misc_cg_uncharge(type, sev->misc_cg, 1);

	put_misc_cg(sev->misc_cg);
@@ -179,17 +180,16 @@ static int sev_get_asid(struct kvm *kvm) 
static void sev_asid_free(struct kvm_sev_info *sev)

{

	struct svm_cpu_data *sd;

	int cpu, pos;

	int cpu;

	enum misc_res_type type;



	mutex_lock(&sev_bitmap_lock);



	pos = sev->asid - 1;

	__set_bit(pos, sev_reclaim_asid_bitmap);

	__set_bit(sev->asid, sev_reclaim_asid_bitmap);



	for_each_possible_cpu(cpu) {

		sd = per_cpu(svm_data, cpu);

		sd->sev_vmcbs[pos] = NULL;

		sd->sev_vmcbs[sev->asid] = NULL;

	}



	mutex_unlock(&sev_bitmap_lock);
@@ -1857,12 +1857,17 @@ void __init sev_hardware_setup(void) 
	min_sev_asid = edx;

	sev_me_mask = 1UL << (ebx & 0x3f);



	/* Initialize SEV ASID bitmaps */

	sev_asid_bitmap = bitmap_zalloc(max_sev_asid, GFP_KERNEL);

	/*

	 * Initialize SEV ASID bitmaps. Allocate space for ASID 0 in the bitmap,

	 * even though it's never used, so that the bitmap is indexed by the

	 * actual ASID.

	 */

	nr_asids = max_sev_asid + 1;

	sev_asid_bitmap = bitmap_zalloc(nr_asids, GFP_KERNEL);

	if (!sev_asid_bitmap)

		goto out;



	sev_reclaim_asid_bitmap = bitmap_zalloc(max_sev_asid, GFP_KERNEL);

	sev_reclaim_asid_bitmap = bitmap_zalloc(nr_asids, GFP_KERNEL);

	if (!sev_reclaim_asid_bitmap) {

		bitmap_free(sev_asid_bitmap);

		sev_asid_bitmap = NULL;
@@ -1907,7 +1912,7 @@ void sev_hardware_teardown(void) 
		return;



	/* No need to take sev_bitmap_lock, all VMs have been destroyed. */

	sev_flush_asids(0, max_sev_asid);

	sev_flush_asids(1, max_sev_asid);



	bitmap_free(sev_asid_bitmap);

	bitmap_free(sev_reclaim_asid_bitmap);
@@ -1921,7 +1926,7 @@ int sev_cpu_init(struct svm_cpu_data *sd) 
	if (!sev_enabled)

		return 0;



	sd->sev_vmcbs = kcalloc(max_sev_asid + 1, sizeof(void *), GFP_KERNEL);

	sd->sev_vmcbs = kcalloc(nr_asids, sizeof(void *), GFP_KERNEL);

	if (!sd->sev_vmcbs)

		return -ENOMEM;

arch/x86/kvm/trace.h

+15 −0
Original line number Diff line number Diff line
@@ -92,6 +92,21 @@ TRACE_EVENT(kvm_hv_hypercall, 
		  __entry->outgpa)

);



TRACE_EVENT(kvm_hv_hypercall_done,

	TP_PROTO(u64 result),

	TP_ARGS(result),



	TP_STRUCT__entry(

		__field(__u64, result)

	),



	TP_fast_assign(

		__entry->result	= result;

	),



	TP_printk("result 0x%llx", __entry->result)

);



/*

 * Tracepoint for Xen hypercall.

 */

arch/x86/kvm/x86.c

+11 −2
Original line number Diff line number Diff line
@@ -4358,8 +4358,17 @@ static int kvm_cpu_accept_dm_intr(struct kvm_vcpu *vcpu) 


static int kvm_vcpu_ready_for_interrupt_injection(struct kvm_vcpu *vcpu)

{

	return kvm_arch_interrupt_allowed(vcpu) &&

		kvm_cpu_accept_dm_intr(vcpu);

	/*

	 * Do not cause an interrupt window exit if an exception

	 * is pending or an event needs reinjection; userspace

	 * might want to inject the interrupt manually using KVM_SET_REGS

	 * or KVM_SET_SREGS.  For that to work, we must be at an

	 * instruction boundary and with no events half-injected.

	 */

	return (kvm_arch_interrupt_allowed(vcpu) &&

		kvm_cpu_accept_dm_intr(vcpu) &&

		!kvm_event_needs_reinjection(vcpu) &&

		!vcpu->arch.exception.pending);

}



static int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu,