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

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

kvm/x86: move Hyper-V MSR's/hypercall code into hyperv.c file 



This patch introduce Hyper-V related source code file - hyperv.c and
per vm and per vcpu hyperv context structures.
All Hyper-V MSR's and hypercall code moved into hyperv.c.
All Hyper-V kvm/vcpu fields moved into appropriate hyperv context
structures. Copyrights and authors information copied from x86.c
to hyperv.c.

Signed-off-by: default avatarAndrey Smetanin <asmetanin@virtuozzo.com>
Signed-off-by: default avatarDenis V. Lunev <den@openvz.org>
Reviewed-by: default avatarPeter Hornyack <peterhornyack@google.com>
CC: Paolo Bonzini <pbonzini@redhat.com>
CC: Gleb Natapov <gleb@kernel.org>
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent f9eb4af6

arch/x86/include/asm/kvm_host.h

+14 −6
Original line number Diff line number Diff line
@@ -358,6 +358,11 @@ struct kvm_mtrr { 
	struct list_head head;

};



/* Hyper-V per vcpu emulation context */

struct kvm_vcpu_hv {

	u64 hv_vapic;

};



struct kvm_vcpu_arch {

	/*

	 * rip and regs accesses must go through
@@ -514,8 +519,7 @@ struct kvm_vcpu_arch { 
	/* used for guest single stepping over the given code position */

	unsigned long singlestep_rip;



	/* fields used by HYPER-V emulation */

	u64 hv_vapic;

	struct kvm_vcpu_hv hyperv;



	cpumask_var_t wbinvd_dirty_mask;
@@ -586,6 +590,13 @@ struct kvm_apic_map { 
	struct kvm_lapic *logical_map[16][16];

};



/* Hyper-V emulation context */

struct kvm_hv {

	u64 hv_guest_os_id;

	u64 hv_hypercall;

	u64 hv_tsc_page;

};



struct kvm_arch {

	unsigned int n_used_mmu_pages;

	unsigned int n_requested_mmu_pages;
@@ -645,10 +656,7 @@ struct kvm_arch { 
	/* reads protected by irq_srcu, writes by irq_lock */

	struct hlist_head mask_notifier_list;



	/* fields used by HYPER-V emulation */

	u64 hv_guest_os_id;

	u64 hv_hypercall;

	u64 hv_tsc_page;

	struct kvm_hv hyperv;



	#ifdef CONFIG_KVM_MMU_AUDIT

	int audit_point;

arch/x86/kvm/Makefile

+3 −1
Original line number Diff line number Diff line
@@ -12,7 +12,9 @@ kvm-y += $(KVM)/kvm_main.o $(KVM)/coalesced_mmio.o \ 
kvm-$(CONFIG_KVM_ASYNC_PF)	+= $(KVM)/async_pf.o



kvm-y			+= x86.o mmu.o emulate.o i8259.o irq.o lapic.o \

			   i8254.o ioapic.o irq_comm.o cpuid.o pmu.o mtrr.o

			   i8254.o ioapic.o irq_comm.o cpuid.o pmu.o mtrr.o \

			   hyperv.o



kvm-$(CONFIG_KVM_DEVICE_ASSIGNMENT)	+= assigned-dev.o iommu.o

kvm-intel-y		+= vmx.o pmu_intel.o

kvm-amd-y		+= svm.o pmu_amd.o

arch/x86/kvm/hyperv.c

0 → 100644
+307 −0
Original line number Diff line number Diff line 
/*

 * KVM Microsoft Hyper-V emulation

 *

 * derived from arch/x86/kvm/x86.c

 *

 * Copyright (C) 2006 Qumranet, Inc.

 * Copyright (C) 2008 Qumranet, Inc.

 * Copyright IBM Corporation, 2008

 * Copyright 2010 Red Hat, Inc. and/or its affiliates.

 * Copyright (C) 2015 Andrey Smetanin <asmetanin@virtuozzo.com>

 *

 * Authors:

 *   Avi Kivity   <avi@qumranet.com>

 *   Yaniv Kamay  <yaniv@qumranet.com>

 *   Amit Shah    <amit.shah@qumranet.com>

 *   Ben-Ami Yassour <benami@il.ibm.com>

 *   Andrey Smetanin <asmetanin@virtuozzo.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2.  See

 * the COPYING file in the top-level directory.

 *

 */



#include "x86.h"

#include "lapic.h"

#include "hyperv.h"



#include <linux/kvm_host.h>

#include <trace/events/kvm.h>



#include "trace.h"



static bool kvm_hv_msr_partition_wide(u32 msr)

{

	bool r = false;



	switch (msr) {

	case HV_X64_MSR_GUEST_OS_ID:

	case HV_X64_MSR_HYPERCALL:

	case HV_X64_MSR_REFERENCE_TSC:

	case HV_X64_MSR_TIME_REF_COUNT:

		r = true;

		break;

	}



	return r;

}



static int kvm_hv_set_msr_pw(struct kvm_vcpu *vcpu, u32 msr, u64 data)

{

	struct kvm *kvm = vcpu->kvm;

	struct kvm_hv *hv = &kvm->arch.hyperv;



	switch (msr) {

	case HV_X64_MSR_GUEST_OS_ID:

		hv->hv_guest_os_id = data;

		/* setting guest os id to zero disables hypercall page */

		if (!hv->hv_guest_os_id)

			hv->hv_hypercall &= ~HV_X64_MSR_HYPERCALL_ENABLE;

		break;

	case HV_X64_MSR_HYPERCALL: {

		u64 gfn;

		unsigned long addr;

		u8 instructions[4];



		/* if guest os id is not set hypercall should remain disabled */

		if (!hv->hv_guest_os_id)

			break;

		if (!(data & HV_X64_MSR_HYPERCALL_ENABLE)) {

			hv->hv_hypercall = data;

			break;

		}

		gfn = data >> HV_X64_MSR_HYPERCALL_PAGE_ADDRESS_SHIFT;

		addr = gfn_to_hva(kvm, gfn);

		if (kvm_is_error_hva(addr))

			return 1;

		kvm_x86_ops->patch_hypercall(vcpu, instructions);

		((unsigned char *)instructions)[3] = 0xc3; /* ret */

		if (__copy_to_user((void __user *)addr, instructions, 4))

			return 1;

		hv->hv_hypercall = data;

		mark_page_dirty(kvm, gfn);

		break;

	}

	case HV_X64_MSR_REFERENCE_TSC: {

		u64 gfn;

		HV_REFERENCE_TSC_PAGE tsc_ref;



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

		hv->hv_tsc_page = data;

		if (!(data & HV_X64_MSR_TSC_REFERENCE_ENABLE))

			break;

		gfn = data >> HV_X64_MSR_TSC_REFERENCE_ADDRESS_SHIFT;

		if (kvm_write_guest(

				kvm,

				gfn << HV_X64_MSR_TSC_REFERENCE_ADDRESS_SHIFT,

				&tsc_ref, sizeof(tsc_ref)))

			return 1;

		mark_page_dirty(kvm, gfn);

		break;

	}

	default:

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

			    msr, data);

		return 1;

	}

	return 0;

}



static int kvm_hv_set_msr(struct kvm_vcpu *vcpu, u32 msr, u64 data)

{

	struct kvm_vcpu_hv *hv = &vcpu->arch.hyperv;



	switch (msr) {

	case HV_X64_MSR_APIC_ASSIST_PAGE: {

		u64 gfn;

		unsigned long addr;



		if (!(data & HV_X64_MSR_APIC_ASSIST_PAGE_ENABLE)) {

			hv->hv_vapic = data;

			if (kvm_lapic_enable_pv_eoi(vcpu, 0))

				return 1;

			break;

		}

		gfn = data >> HV_X64_MSR_APIC_ASSIST_PAGE_ADDRESS_SHIFT;

		addr = kvm_vcpu_gfn_to_hva(vcpu, gfn);

		if (kvm_is_error_hva(addr))

			return 1;

		if (__clear_user((void __user *)addr, PAGE_SIZE))

			return 1;

		hv->hv_vapic = data;

		kvm_vcpu_mark_page_dirty(vcpu, gfn);

		if (kvm_lapic_enable_pv_eoi(vcpu,

					    gfn_to_gpa(gfn) | KVM_MSR_ENABLED))

			return 1;

		break;

	}

	case HV_X64_MSR_EOI:

		return kvm_hv_vapic_msr_write(vcpu, APIC_EOI, data);

	case HV_X64_MSR_ICR:

		return kvm_hv_vapic_msr_write(vcpu, APIC_ICR, data);

	case HV_X64_MSR_TPR:

		return kvm_hv_vapic_msr_write(vcpu, APIC_TASKPRI, data);

	default:

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

			    msr, data);

		return 1;

	}



	return 0;

}



static int kvm_hv_get_msr_pw(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)

{

	u64 data = 0;

	struct kvm *kvm = vcpu->kvm;

	struct kvm_hv *hv = &kvm->arch.hyperv;



	switch (msr) {

	case HV_X64_MSR_GUEST_OS_ID:

		data = hv->hv_guest_os_id;

		break;

	case HV_X64_MSR_HYPERCALL:

		data = hv->hv_hypercall;

		break;

	case HV_X64_MSR_TIME_REF_COUNT: {

		data =

		     div_u64(get_kernel_ns() + kvm->arch.kvmclock_offset, 100);

		break;

	}

	case HV_X64_MSR_REFERENCE_TSC:

		data = hv->hv_tsc_page;

		break;

	default:

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

		return 1;

	}



	*pdata = data;

	return 0;

}



static int kvm_hv_get_msr(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)

{

	u64 data = 0;

	struct kvm_vcpu_hv *hv = &vcpu->arch.hyperv;



	switch (msr) {

	case HV_X64_MSR_VP_INDEX: {

		int r;

		struct kvm_vcpu *v;



		kvm_for_each_vcpu(r, v, vcpu->kvm) {

			if (v == vcpu) {

				data = r;

				break;

			}

		}

		break;

	}

	case HV_X64_MSR_EOI:

		return kvm_hv_vapic_msr_read(vcpu, APIC_EOI, pdata);

	case HV_X64_MSR_ICR:

		return kvm_hv_vapic_msr_read(vcpu, APIC_ICR, pdata);

	case HV_X64_MSR_TPR:

		return kvm_hv_vapic_msr_read(vcpu, APIC_TASKPRI, pdata);

	case HV_X64_MSR_APIC_ASSIST_PAGE:

		data = hv->hv_vapic;

		break;

	default:

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

		return 1;

	}

	*pdata = data;

	return 0;

}



int kvm_hv_set_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 data)

{

	if (kvm_hv_msr_partition_wide(msr)) {

		int r;



		mutex_lock(&vcpu->kvm->lock);

		r = kvm_hv_set_msr_pw(vcpu, msr, data);

		mutex_unlock(&vcpu->kvm->lock);

		return r;

	} else

		return kvm_hv_set_msr(vcpu, msr, data);

}



int kvm_hv_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)

{

	if (kvm_hv_msr_partition_wide(msr)) {

		int r;



		mutex_lock(&vcpu->kvm->lock);

		r = kvm_hv_get_msr_pw(vcpu, msr, pdata);

		mutex_unlock(&vcpu->kvm->lock);

		return r;

	} else

		return kvm_hv_get_msr(vcpu, msr, pdata);

}



bool kvm_hv_hypercall_enabled(struct kvm *kvm)

{

	return kvm->arch.hyperv.hv_hypercall & HV_X64_MSR_HYPERCALL_ENABLE;

}



int kvm_hv_hypercall(struct kvm_vcpu *vcpu)

{

	u64 param, ingpa, outgpa, ret;

	uint16_t code, rep_idx, rep_cnt, res = HV_STATUS_SUCCESS, rep_done = 0;

	bool fast, longmode;



	/*

	 * hypercall generates UD from non zero cpl and real mode

	 * per HYPER-V spec

	 */

	if (kvm_x86_ops->get_cpl(vcpu) != 0 || !is_protmode(vcpu)) {

		kvm_queue_exception(vcpu, UD_VECTOR);

		return 0;

	}



	longmode = is_64_bit_mode(vcpu);



	if (!longmode) {

		param = ((u64)kvm_register_read(vcpu, VCPU_REGS_RDX) << 32) |

			(kvm_register_read(vcpu, VCPU_REGS_RAX) & 0xffffffff);

		ingpa = ((u64)kvm_register_read(vcpu, VCPU_REGS_RBX) << 32) |

			(kvm_register_read(vcpu, VCPU_REGS_RCX) & 0xffffffff);

		outgpa = ((u64)kvm_register_read(vcpu, VCPU_REGS_RDI) << 32) |

			(kvm_register_read(vcpu, VCPU_REGS_RSI) & 0xffffffff);

	}

#ifdef CONFIG_X86_64

	else {

		param = kvm_register_read(vcpu, VCPU_REGS_RCX);

		ingpa = kvm_register_read(vcpu, VCPU_REGS_RDX);

		outgpa = kvm_register_read(vcpu, VCPU_REGS_R8);

	}

#endif



	code = param & 0xffff;

	fast = (param >> 16) & 0x1;

	rep_cnt = (param >> 32) & 0xfff;

	rep_idx = (param >> 48) & 0xfff;



	trace_kvm_hv_hypercall(code, fast, rep_cnt, rep_idx, ingpa, outgpa);



	switch (code) {

	case HV_X64_HV_NOTIFY_LONG_SPIN_WAIT:

		kvm_vcpu_on_spin(vcpu);

		break;

	default:

		res = HV_STATUS_INVALID_HYPERCALL_CODE;

		break;

	}



	ret = res | (((u64)rep_done & 0xfff) << 32);

	if (longmode) {

		kvm_register_write(vcpu, VCPU_REGS_RAX, ret);

	} else {

		kvm_register_write(vcpu, VCPU_REGS_RDX, ret >> 32);

		kvm_register_write(vcpu, VCPU_REGS_RAX, ret & 0xffffffff);

	}



	return 1;

}

arch/x86/kvm/hyperv.h

0 → 100644
+32 −0
Original line number Diff line number Diff line 
/*

 * KVM Microsoft Hyper-V emulation

 *

 * derived from arch/x86/kvm/x86.c

 *

 * Copyright (C) 2006 Qumranet, Inc.

 * Copyright (C) 2008 Qumranet, Inc.

 * Copyright IBM Corporation, 2008

 * Copyright 2010 Red Hat, Inc. and/or its affiliates.

 * Copyright (C) 2015 Andrey Smetanin <asmetanin@virtuozzo.com>

 *

 * Authors:

 *   Avi Kivity   <avi@qumranet.com>

 *   Yaniv Kamay  <yaniv@qumranet.com>

 *   Amit Shah    <amit.shah@qumranet.com>

 *   Ben-Ami Yassour <benami@il.ibm.com>

 *   Andrey Smetanin <asmetanin@virtuozzo.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2.  See

 * the COPYING file in the top-level directory.

 *

 */



#ifndef __ARCH_X86_KVM_HYPERV_H__

#define __ARCH_X86_KVM_HYPERV_H__



int kvm_hv_set_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 data);

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);



#endif

arch/x86/kvm/lapic.h

+1 −1
Original line number Diff line number Diff line
@@ -91,7 +91,7 @@ int kvm_hv_vapic_msr_read(struct kvm_vcpu *vcpu, u32 msr, u64 *data); 


static inline bool kvm_hv_vapic_assist_page_enabled(struct kvm_vcpu *vcpu)

{

	return vcpu->arch.hv_vapic & HV_X64_MSR_APIC_ASSIST_PAGE_ENABLE;

	return vcpu->arch.hyperv.hv_vapic & HV_X64_MSR_APIC_ASSIST_PAGE_ENABLE;

}



int kvm_lapic_enable_pv_eoi(struct kvm_vcpu *vcpu, u64 data);