Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5c919412 authored by Andrey Smetanin's avatar Andrey Smetanin Committed by Paolo Bonzini
Browse files

kvm/x86: Hyper-V synthetic interrupt controller 



SynIC (synthetic interrupt controller) is a lapic extension,
which is controlled via MSRs and maintains for each vCPU
 - 16 synthetic interrupt "lines" (SINT's); each can be configured to
   trigger a specific interrupt vector optionally with auto-EOI
   semantics
 - a message page in the guest memory with 16 256-byte per-SINT message
   slots
 - an event flag page in the guest memory with 16 2048-bit per-SINT
   event flag areas

The host triggers a SINT whenever it delivers a new message to the
corresponding slot or flips an event flag bit in the corresponding area.
The guest informs the host that it can try delivering a message by
explicitly asserting EOI in lapic or writing to End-Of-Message (EOM)
MSR.

The userspace (qemu) triggers interrupts and receives EOM notifications
via irqfd with resampler; for that, a GSI is allocated for each
configured SINT, and irq_routing api is extended to support GSI-SINT
mapping.

Changes v4:
* added activation of SynIC by vcpu KVM_ENABLE_CAP
* added per SynIC active flag
* added deactivation of APICv upon SynIC activation

Changes v3:
* added KVM_CAP_HYPERV_SYNIC and KVM_IRQ_ROUTING_HV_SINT notes into
docs

Changes v2:
* do not use posted interrupts for Hyper-V SynIC AutoEOI vectors
* add Hyper-V SynIC vectors into EOI exit bitmap
* Hyper-V SyniIC SINT msr write logic simplified

Signed-off-by: default avatarAndrey Smetanin <asmetanin@virtuozzo.com>
Reviewed-by: default avatarRoman Kagan <rkagan@virtuozzo.com>
Signed-off-by: default avatarDenis V. Lunev <den@openvz.org>
CC: Gleb Natapov <gleb@kernel.org>
CC: Paolo Bonzini <pbonzini@redhat.com>
CC: Roman Kagan <rkagan@virtuozzo.com>
CC: Denis V. Lunev <den@openvz.org>
CC: qemu-devel@nongnu.org
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent d62caabb

Documentation/virtual/kvm/api.txt

+19 −0
Original line number Diff line number Diff line
@@ -1451,6 +1451,7 @@ struct kvm_irq_routing_entry { 
		struct kvm_irq_routing_irqchip irqchip;

		struct kvm_irq_routing_msi msi;

		struct kvm_irq_routing_s390_adapter adapter;

		struct kvm_irq_routing_hv_sint hv_sint;

		__u32 pad[8];

	} u;

};
@@ -1459,6 +1460,7 @@ struct kvm_irq_routing_entry { 
#define KVM_IRQ_ROUTING_IRQCHIP 1

#define KVM_IRQ_ROUTING_MSI 2

#define KVM_IRQ_ROUTING_S390_ADAPTER 3

#define KVM_IRQ_ROUTING_HV_SINT 4



No flags are specified so far, the corresponding field must be set to zero.
@@ -1482,6 +1484,10 @@ struct kvm_irq_routing_s390_adapter { 
	__u32 adapter_id;

};



struct kvm_irq_routing_hv_sint {

	__u32 vcpu;

	__u32 sint;

};



4.53 KVM_ASSIGN_SET_MSIX_NR (deprecated)
@@ -3685,3 +3691,16 @@ available, means that that the kernel has an implementation of the 
H_RANDOM hypercall backed by a hardware random-number generator.

If present, the kernel H_RANDOM handler can be enabled for guest use

with the KVM_CAP_PPC_ENABLE_HCALL capability.



8.2 KVM_CAP_HYPERV_SYNIC



Architectures: x86

This capability, if KVM_CHECK_EXTENSION indicates that it is

available, means that that the kernel has an implementation of the

Hyper-V Synthetic interrupt controller(SynIC). Hyper-V SynIC is

used to support Windows Hyper-V based guest paravirt drivers(VMBus).



In order to use SynIC, it has to be activated by setting this

capability via KVM_ENABLE_CAP ioctl on the vcpu fd. Note that this

will disable the use of APIC hardware virtualization even if supported

by the CPU, as it's incompatible with SynIC auto-EOI behavior.

arch/x86/include/asm/kvm_host.h

+15 −0
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 
#include <linux/pvclock_gtod.h>

#include <linux/clocksource.h>

#include <linux/irqbypass.h>

#include <linux/hyperv.h>



#include <asm/pvclock-abi.h>

#include <asm/desc.h>
@@ -374,10 +375,24 @@ struct kvm_mtrr { 
	struct list_head head;

};



/* Hyper-V synthetic interrupt controller (SynIC)*/

struct kvm_vcpu_hv_synic {

	u64 version;

	u64 control;

	u64 msg_page;

	u64 evt_page;

	atomic64_t sint[HV_SYNIC_SINT_COUNT];

	atomic_t sint_to_gsi[HV_SYNIC_SINT_COUNT];

	DECLARE_BITMAP(auto_eoi_bitmap, 256);

	DECLARE_BITMAP(vec_bitmap, 256);

	bool active;

};



/* Hyper-V per vcpu emulation context */

struct kvm_vcpu_hv {

	u64 hv_vapic;

	s64 runtime_offset;

	struct kvm_vcpu_hv_synic synic;

};



struct kvm_vcpu_arch {

arch/x86/kvm/hyperv.c

+315 −0
Original line number Diff line number Diff line
@@ -23,13 +23,314 @@ 


#include "x86.h"

#include "lapic.h"

#include "ioapic.h"

#include "hyperv.h"



#include <linux/kvm_host.h>

#include <asm/apicdef.h>

#include <trace/events/kvm.h>



#include "trace.h"



static inline u64 synic_read_sint(struct kvm_vcpu_hv_synic *synic, int sint)

{

	return atomic64_read(&synic->sint[sint]);

}



static inline int synic_get_sint_vector(u64 sint_value)

{

	if (sint_value & HV_SYNIC_SINT_MASKED)

		return -1;

	return sint_value & HV_SYNIC_SINT_VECTOR_MASK;

}



static bool synic_has_vector_connected(struct kvm_vcpu_hv_synic *synic,

				      int vector)

{

	int i;



	for (i = 0; i < ARRAY_SIZE(synic->sint); i++) {

		if (synic_get_sint_vector(synic_read_sint(synic, i)) == vector)

			return true;

	}

	return false;

}



static bool synic_has_vector_auto_eoi(struct kvm_vcpu_hv_synic *synic,

				     int vector)

{

	int i;

	u64 sint_value;



	for (i = 0; i < ARRAY_SIZE(synic->sint); i++) {

		sint_value = synic_read_sint(synic, i);

		if (synic_get_sint_vector(sint_value) == vector &&

		    sint_value & HV_SYNIC_SINT_AUTO_EOI)

			return true;

	}

	return false;

}



static int synic_set_sint(struct kvm_vcpu_hv_synic *synic, int sint, u64 data)

{

	int vector;



	vector = data & HV_SYNIC_SINT_VECTOR_MASK;

	if (vector < 16)

		return 1;

	/*

	 * Guest may configure multiple SINTs to use the same vector, so

	 * we maintain a bitmap of vectors handled by synic, and a

	 * bitmap of vectors with auto-eoi behavior.  The bitmaps are

	 * updated here, and atomically queried on fast paths.

	 */



	atomic64_set(&synic->sint[sint], data);



	if (synic_has_vector_connected(synic, vector))

		__set_bit(vector, synic->vec_bitmap);

	else

		__clear_bit(vector, synic->vec_bitmap);



	if (synic_has_vector_auto_eoi(synic, vector))

		__set_bit(vector, synic->auto_eoi_bitmap);

	else

		__clear_bit(vector, synic->auto_eoi_bitmap);



	/* Load SynIC vectors into EOI exit bitmap */

	kvm_make_request(KVM_REQ_SCAN_IOAPIC, synic_to_vcpu(synic));

	return 0;

}



static struct kvm_vcpu_hv_synic *synic_get(struct kvm *kvm, u32 vcpu_id)

{

	struct kvm_vcpu *vcpu;

	struct kvm_vcpu_hv_synic *synic;



	if (vcpu_id >= atomic_read(&kvm->online_vcpus))

		return NULL;

	vcpu = kvm_get_vcpu(kvm, vcpu_id);

	if (!vcpu)

		return NULL;

	synic = vcpu_to_synic(vcpu);

	return (synic->active) ? synic : NULL;

}



static void kvm_hv_notify_acked_sint(struct kvm_vcpu *vcpu, u32 sint)

{

	struct kvm *kvm = vcpu->kvm;

	int gsi, idx;



	vcpu_debug(vcpu, "Hyper-V SynIC acked sint %d\n", sint);



	idx = srcu_read_lock(&kvm->irq_srcu);

	gsi = atomic_read(&vcpu_to_synic(vcpu)->sint_to_gsi[sint]);

	if (gsi != -1)

		kvm_notify_acked_gsi(kvm, gsi);

	srcu_read_unlock(&kvm->irq_srcu, idx);

}



static int synic_set_msr(struct kvm_vcpu_hv_synic *synic,

			 u32 msr, u64 data, bool host)

{

	struct kvm_vcpu *vcpu = synic_to_vcpu(synic);

	int ret;



	if (!synic->active)

		return 1;



	vcpu_debug(vcpu, "Hyper-V SynIC set msr 0x%x 0x%llx host %d\n",

		   msr, data, host);

	ret = 0;

	switch (msr) {

	case HV_X64_MSR_SCONTROL:

		synic->control = data;

		break;

	case HV_X64_MSR_SVERSION:

		if (!host) {

			ret = 1;

			break;

		}

		synic->version = data;

		break;

	case HV_X64_MSR_SIEFP:

		if (data & HV_SYNIC_SIEFP_ENABLE)

			if (kvm_clear_guest(vcpu->kvm,

					    data & PAGE_MASK, PAGE_SIZE)) {

				ret = 1;

				break;

			}

		synic->evt_page = data;

		break;

	case HV_X64_MSR_SIMP:

		if (data & HV_SYNIC_SIMP_ENABLE)

			if (kvm_clear_guest(vcpu->kvm,

					    data & PAGE_MASK, PAGE_SIZE)) {

				ret = 1;

				break;

			}

		synic->msg_page = data;

		break;

	case HV_X64_MSR_EOM: {

		int i;



		for (i = 0; i < ARRAY_SIZE(synic->sint); i++)

			kvm_hv_notify_acked_sint(vcpu, i);

		break;

	}

	case HV_X64_MSR_SINT0 ... HV_X64_MSR_SINT15:

		ret = synic_set_sint(synic, msr - HV_X64_MSR_SINT0, data);

		break;

	default:

		ret = 1;

		break;

	}

	return ret;

}



static int synic_get_msr(struct kvm_vcpu_hv_synic *synic, u32 msr, u64 *pdata)

{

	int ret;



	if (!synic->active)

		return 1;



	ret = 0;

	switch (msr) {

	case HV_X64_MSR_SCONTROL:

		*pdata = synic->control;

		break;

	case HV_X64_MSR_SVERSION:

		*pdata = synic->version;

		break;

	case HV_X64_MSR_SIEFP:

		*pdata = synic->evt_page;

		break;

	case HV_X64_MSR_SIMP:

		*pdata = synic->msg_page;

		break;

	case HV_X64_MSR_EOM:

		*pdata = 0;

		break;

	case HV_X64_MSR_SINT0 ... HV_X64_MSR_SINT15:

		*pdata = atomic64_read(&synic->sint[msr - HV_X64_MSR_SINT0]);

		break;

	default:

		ret = 1;

		break;

	}

	return ret;

}



int synic_set_irq(struct kvm_vcpu_hv_synic *synic, u32 sint)

{

	struct kvm_vcpu *vcpu = synic_to_vcpu(synic);

	struct kvm_lapic_irq irq;

	int ret, vector;



	if (sint >= ARRAY_SIZE(synic->sint))

		return -EINVAL;



	vector = synic_get_sint_vector(synic_read_sint(synic, sint));

	if (vector < 0)

		return -ENOENT;



	memset(&irq, 0, sizeof(irq));

	irq.dest_id = kvm_apic_id(vcpu->arch.apic);

	irq.dest_mode = APIC_DEST_PHYSICAL;

	irq.delivery_mode = APIC_DM_FIXED;

	irq.vector = vector;

	irq.level = 1;



	ret = kvm_irq_delivery_to_apic(vcpu->kvm, NULL, &irq, NULL);

	vcpu_debug(vcpu, "Hyper-V SynIC set irq ret %d\n", ret);

	return ret;

}



int kvm_hv_synic_set_irq(struct kvm *kvm, u32 vcpu_id, u32 sint)

{

	struct kvm_vcpu_hv_synic *synic;



	synic = synic_get(kvm, vcpu_id);

	if (!synic)

		return -EINVAL;



	return synic_set_irq(synic, sint);

}



void kvm_hv_synic_send_eoi(struct kvm_vcpu *vcpu, int vector)

{

	struct kvm_vcpu_hv_synic *synic = vcpu_to_synic(vcpu);

	int i;



	vcpu_debug(vcpu, "Hyper-V SynIC send eoi vec %d\n", vector);



	for (i = 0; i < ARRAY_SIZE(synic->sint); i++)

		if (synic_get_sint_vector(synic_read_sint(synic, i)) == vector)

			kvm_hv_notify_acked_sint(vcpu, i);

}



static int kvm_hv_set_sint_gsi(struct kvm *kvm, u32 vcpu_id, u32 sint, int gsi)

{

	struct kvm_vcpu_hv_synic *synic;



	synic = synic_get(kvm, vcpu_id);

	if (!synic)

		return -EINVAL;



	if (sint >= ARRAY_SIZE(synic->sint_to_gsi))

		return -EINVAL;



	atomic_set(&synic->sint_to_gsi[sint], gsi);

	return 0;

}



void kvm_hv_irq_routing_update(struct kvm *kvm)

{

	struct kvm_irq_routing_table *irq_rt;

	struct kvm_kernel_irq_routing_entry *e;

	u32 gsi;



	irq_rt = srcu_dereference_check(kvm->irq_routing, &kvm->irq_srcu,

					lockdep_is_held(&kvm->irq_lock));



	for (gsi = 0; gsi < irq_rt->nr_rt_entries; gsi++) {

		hlist_for_each_entry(e, &irq_rt->map[gsi], link) {

			if (e->type == KVM_IRQ_ROUTING_HV_SINT)

				kvm_hv_set_sint_gsi(kvm, e->hv_sint.vcpu,

						    e->hv_sint.sint, gsi);

		}

	}

}



static void synic_init(struct kvm_vcpu_hv_synic *synic)

{

	int i;



	memset(synic, 0, sizeof(*synic));

	synic->version = HV_SYNIC_VERSION_1;

	for (i = 0; i < ARRAY_SIZE(synic->sint); i++) {

		atomic64_set(&synic->sint[i], HV_SYNIC_SINT_MASKED);

		atomic_set(&synic->sint_to_gsi[i], -1);

	}

}



void kvm_hv_vcpu_init(struct kvm_vcpu *vcpu)

{

	synic_init(vcpu_to_synic(vcpu));

}



int kvm_hv_activate_synic(struct kvm_vcpu *vcpu)

{

	/*

	 * Hyper-V SynIC auto EOI SINT's are

	 * not compatible with APICV, so deactivate APICV

	 */

	kvm_vcpu_deactivate_apicv(vcpu);

	vcpu_to_synic(vcpu)->active = true;

	return 0;

}



static bool kvm_hv_msr_partition_wide(u32 msr)

{

	bool r = false;
@@ -226,6 +527,13 @@ static int kvm_hv_set_msr(struct kvm_vcpu *vcpu, u32 msr, u64 data, bool host) 
			return 1;

		hv->runtime_offset = data - current_task_runtime_100ns();

		break;

	case HV_X64_MSR_SCONTROL:

	case HV_X64_MSR_SVERSION:

	case HV_X64_MSR_SIEFP:

	case HV_X64_MSR_SIMP:

	case HV_X64_MSR_EOM:

	case HV_X64_MSR_SINT0 ... HV_X64_MSR_SINT15:

		return synic_set_msr(vcpu_to_synic(vcpu), msr, data, host);

	default:

		vcpu_unimpl(vcpu, "Hyper-V uhandled wrmsr: 0x%x data 0x%llx\n",

			    msr, data);
@@ -304,6 +612,13 @@ static int kvm_hv_get_msr(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata) 
	case HV_X64_MSR_VP_RUNTIME:

		data = current_task_runtime_100ns() + hv->runtime_offset;

		break;

	case HV_X64_MSR_SCONTROL:

	case HV_X64_MSR_SVERSION:

	case HV_X64_MSR_SIEFP:

	case HV_X64_MSR_SIMP:

	case HV_X64_MSR_EOM:

	case HV_X64_MSR_SINT0 ... HV_X64_MSR_SINT15:

		return synic_get_msr(vcpu_to_synic(vcpu), msr, pdata);

	default:

		vcpu_unimpl(vcpu, "Hyper-V unhandled rdmsr: 0x%x\n", msr);

		return 1;

arch/x86/kvm/hyperv.h

+23 −0
Original line number Diff line number Diff line
@@ -29,4 +29,27 @@ int kvm_hv_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata); 
bool kvm_hv_hypercall_enabled(struct kvm *kvm);

int kvm_hv_hypercall(struct kvm_vcpu *vcpu);



int kvm_hv_synic_set_irq(struct kvm *kvm, u32 vcpu_id, u32 sint);

void kvm_hv_synic_send_eoi(struct kvm_vcpu *vcpu, int vector);



static inline struct kvm_vcpu_hv_synic *vcpu_to_synic(struct kvm_vcpu *vcpu)

{

	return &vcpu->arch.hyperv.synic;

}



static inline struct kvm_vcpu *synic_to_vcpu(struct kvm_vcpu_hv_synic *synic)

{

	struct kvm_vcpu_hv *hv;

	struct kvm_vcpu_arch *arch;



	hv = container_of(synic, struct kvm_vcpu_hv, synic);

	arch = container_of(hv, struct kvm_vcpu_arch, hyperv);

	return container_of(arch, struct kvm_vcpu, arch);

}

void kvm_hv_irq_routing_update(struct kvm *kvm);



void kvm_hv_vcpu_init(struct kvm_vcpu *vcpu);



int kvm_hv_activate_synic(struct kvm_vcpu *vcpu);



#endif

arch/x86/kvm/irq_comm.c

+34 −0
Original line number Diff line number Diff line
@@ -33,6 +33,8 @@ 


#include "lapic.h"



#include "hyperv.h"



static int kvm_set_pic_irq(struct kvm_kernel_irq_routing_entry *e,

			   struct kvm *kvm, int irq_source_id, int level,

			   bool line_status)
@@ -219,6 +221,16 @@ void kvm_fire_mask_notifiers(struct kvm *kvm, unsigned irqchip, unsigned pin, 
	srcu_read_unlock(&kvm->irq_srcu, idx);

}



static int kvm_hv_set_sint(struct kvm_kernel_irq_routing_entry *e,

		    struct kvm *kvm, int irq_source_id, int level,

		    bool line_status)

{

	if (!level)

		return -1;



	return kvm_hv_synic_set_irq(kvm, e->hv_sint.vcpu, e->hv_sint.sint);

}



int kvm_set_routing_entry(struct kvm_kernel_irq_routing_entry *e,

			  const struct kvm_irq_routing_entry *ue)

{
@@ -257,6 +269,11 @@ int kvm_set_routing_entry(struct kvm_kernel_irq_routing_entry *e, 
		e->msi.address_hi = ue->u.msi.address_hi;

		e->msi.data = ue->u.msi.data;

		break;

	case KVM_IRQ_ROUTING_HV_SINT:

		e->set = kvm_hv_set_sint;

		e->hv_sint.vcpu = ue->u.hv_sint.vcpu;

		e->hv_sint.sint = ue->u.hv_sint.sint;

		break;

	default:

		goto out;

	}
@@ -376,3 +393,20 @@ void kvm_scan_ioapic_routes(struct kvm_vcpu *vcpu, 
	}

	srcu_read_unlock(&kvm->irq_srcu, idx);

}



int kvm_arch_set_irq(struct kvm_kernel_irq_routing_entry *irq, struct kvm *kvm,

		     int irq_source_id, int level, bool line_status)

{

	switch (irq->type) {

	case KVM_IRQ_ROUTING_HV_SINT:

		return kvm_hv_set_sint(irq, kvm, irq_source_id, level,

				       line_status);

	default:

		return -EWOULDBLOCK;

	}

}



void kvm_arch_irq_routing_update(struct kvm *kvm)

{

	kvm_hv_irq_routing_update(kvm);

}