Commit 40da8ccd authored by David Woodhouse's avatar David Woodhouse
Browse files

KVM: x86/xen: Add event channel interrupt vector upcall 



It turns out that we can't handle event channels *entirely* in userspace
by delivering them as ExtINT, because KVM is a bit picky about when it
accepts ExtINT interrupts from a legacy PIC. The in-kernel local APIC
has to have LVT0 configured in APIC_MODE_EXTINT and unmasked, which
isn't necessarily the case for Xen guests especially on secondary CPUs.

To cope with this, add kvm_xen_get_interrupt() which checks the
evtchn_pending_upcall field in the Xen vcpu_info, and delivers the Xen
upcall vector (configured by KVM_XEN_ATTR_TYPE_UPCALL_VECTOR) if it's
set regardless of LAPIC LVT0 configuration. This gives us the minimum
support we need for completely userspace-based implementation of event
channels.

This does mean that vcpu_enter_guest() needs to check for the
evtchn_pending_upcall flag being set, because it can't rely on someone
having set KVM_REQ_EVENT unless we were to add some way for userspace to
do so manually.

Signed-off-by: default avatarDavid Woodhouse <dwmw@amazon.co.uk>
parent f2340cd9

arch/x86/include/asm/kvm_host.h

+1 −0
Original line number Diff line number Diff line
@@ -913,6 +913,7 @@ struct msr_bitmap_range { 
struct kvm_xen {

	bool long_mode;

	bool shinfo_set;

	u8 upcall_vector;

	struct gfn_to_hva_cache shinfo_cache;

};

arch/x86/kvm/irq.c

+7 −0
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
#include "irq.h"

#include "i8254.h"

#include "x86.h"

#include "xen.h"



/*

 * check if there are pending timer events
@@ -56,6 +57,9 @@ int kvm_cpu_has_extint(struct kvm_vcpu *v) 
	if (!lapic_in_kernel(v))

		return v->arch.interrupt.injected;



	if (kvm_xen_has_interrupt(v))

		return 1;



	if (!kvm_apic_accept_pic_intr(v))

		return 0;
@@ -110,6 +114,9 @@ static int kvm_cpu_get_extint(struct kvm_vcpu *v) 
	if (!lapic_in_kernel(v))

		return v->arch.interrupt.nr;



	if (kvm_xen_has_interrupt(v))

		return v->kvm->arch.xen.upcall_vector;



	if (irqchip_split(v->kvm)) {

		int vector = v->arch.pending_external_vector;

arch/x86/kvm/x86.c

+2 −1
Original line number Diff line number Diff line
@@ -8987,7 +8987,8 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) 
			static_call(kvm_x86_msr_filter_changed)(vcpu);

	}



	if (kvm_check_request(KVM_REQ_EVENT, vcpu) || req_int_win) {

	if (kvm_check_request(KVM_REQ_EVENT, vcpu) || req_int_win ||

	    kvm_xen_has_interrupt(vcpu)) {

		++vcpu->stat.req_event;

		kvm_apic_accept_events(vcpu);

		if (vcpu->arch.mp_state == KVM_MP_STATE_INIT_RECEIVED) {

arch/x86/kvm/xen.c

+53 −0
Original line number Diff line number Diff line
@@ -61,6 +61,44 @@ static int kvm_xen_shared_info_init(struct kvm *kvm, gfn_t gfn) 
	return ret;

}



int __kvm_xen_has_interrupt(struct kvm_vcpu *v)

{

	u8 rc = 0;



	/*

	 * If the global upcall vector (HVMIRQ_callback_vector) is set and

	 * the vCPU's evtchn_upcall_pending flag is set, the IRQ is pending.

	 */

	struct gfn_to_hva_cache *ghc = &v->arch.xen.vcpu_info_cache;

	struct kvm_memslots *slots = kvm_memslots(v->kvm);

	unsigned int offset = offsetof(struct vcpu_info, evtchn_upcall_pending);



	/* No need for compat handling here */

	BUILD_BUG_ON(offsetof(struct vcpu_info, evtchn_upcall_pending) !=

		     offsetof(struct compat_vcpu_info, evtchn_upcall_pending));

	BUILD_BUG_ON(sizeof(rc) !=

		     sizeof(((struct vcpu_info *)0)->evtchn_upcall_pending));

	BUILD_BUG_ON(sizeof(rc) !=

		     sizeof(((struct compat_vcpu_info *)0)->evtchn_upcall_pending));



	/*

	 * For efficiency, this mirrors the checks for using the valid

	 * cache in kvm_read_guest_offset_cached(), but just uses

	 * __get_user() instead. And falls back to the slow path.

	 */

	if (likely(slots->generation == ghc->generation &&

		   !kvm_is_error_hva(ghc->hva) && ghc->memslot)) {

		/* Fast path */

		__get_user(rc, (u8 __user *)ghc->hva + offset);

	} else {

		/* Slow path */

		kvm_read_guest_offset_cached(v->kvm, ghc, &rc, offset,

					     sizeof(rc));

	}



	return rc;

}



int kvm_xen_hvm_set_attr(struct kvm *kvm, struct kvm_xen_hvm_attr *data)

{

	int r = -ENOENT;
@@ -83,6 +121,16 @@ int kvm_xen_hvm_set_attr(struct kvm *kvm, struct kvm_xen_hvm_attr *data) 
		r = kvm_xen_shared_info_init(kvm, data->u.shared_info.gfn);

		break;





	case KVM_XEN_ATTR_TYPE_UPCALL_VECTOR:

		if (data->u.vector < 0x10)

			r = -EINVAL;

		else {

			kvm->arch.xen.upcall_vector = data->u.vector;

			r = 0;

		}

		break;



	default:

		break;

	}
@@ -110,6 +158,11 @@ int kvm_xen_hvm_get_attr(struct kvm *kvm, struct kvm_xen_hvm_attr *data) 
		}

		break;



	case KVM_XEN_ATTR_TYPE_UPCALL_VECTOR:

		data->u.vector = kvm->arch.xen.upcall_vector;

		r = 0;

		break;



	default:

		break;

	}

arch/x86/kvm/xen.h

+9 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 


extern struct static_key_false_deferred kvm_xen_enabled;



int __kvm_xen_has_interrupt(struct kvm_vcpu *vcpu);

int kvm_xen_vcpu_set_attr(struct kvm_vcpu *vcpu, struct kvm_xen_vcpu_attr *data);

int kvm_xen_vcpu_get_attr(struct kvm_vcpu *vcpu, struct kvm_xen_vcpu_attr *data);

int kvm_xen_hvm_set_attr(struct kvm *kvm, struct kvm_xen_hvm_attr *data);
@@ -29,6 +30,14 @@ static inline bool kvm_xen_hypercall_enabled(struct kvm *kvm) 
		 KVM_XEN_HVM_CONFIG_INTERCEPT_HCALL);

}



static inline int kvm_xen_has_interrupt(struct kvm_vcpu *vcpu)

{

	if (static_branch_unlikely(&kvm_xen_enabled.key) &&

	    vcpu->arch.xen.vcpu_info_set && vcpu->kvm->arch.xen.upcall_vector)

		return __kvm_xen_has_interrupt(vcpu);



	return 0;

}



/* 32-bit compatibility definitions, also used natively in 32-bit build */

#include <asm/pvclock-abi.h>