hyperv.c File Reference

#include <linux/errno.h>
#include <linux/smp.h>
#include "../cpuid.h"
#include "hyperv.h"
#include "nested.h"
#include "vmcs.h"
#include "vmx.h"
#include "trace.h"

Include dependency graph for hyperv.c:

Go to the source code of this file.

Macros
#define	pr_fmt(fmt)   KBUILD_MODNAME ": " fmt
#define	CC   KVM_NESTED_VMENTER_CONSISTENCY_CHECK

Enumerations
enum	evmcs_revision { EVMCSv1_LEGACY , NR_EVMCS_REVISIONS }
enum	evmcs_ctrl_type {   EVMCS_EXIT_CTRLS , EVMCS_ENTRY_CTRLS , EVMCS_EXEC_CTRL , EVMCS_2NDEXEC ,   EVMCS_3RDEXEC , EVMCS_PINCTRL , EVMCS_VMFUNC , NR_EVMCS_CTRLS }

Functions
u64	nested_get_evmptr (struct kvm_vcpu *vcpu)
uint16_t	nested_get_evmcs_version (struct kvm_vcpu *vcpu)
static u32	evmcs_get_supported_ctls (enum evmcs_ctrl_type ctrl_type)
static bool	evmcs_has_perf_global_ctrl (struct kvm_vcpu *vcpu)
void	nested_evmcs_filter_control_msr (struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata)
static bool	nested_evmcs_is_valid_controls (enum evmcs_ctrl_type ctrl_type, u32 val)
int	nested_evmcs_check_controls (struct vmcs12 *vmcs12)
int	nested_enable_evmcs (struct kvm_vcpu *vcpu, uint16_t *vmcs_version)
bool	nested_evmcs_l2_tlb_flush_enabled (struct kvm_vcpu *vcpu)
void	vmx_hv_inject_synthetic_vmexit_post_tlb_flush (struct kvm_vcpu *vcpu)

Variables
static const u32	evmcs_supported_ctrls [NR_EVMCS_CTRLS][NR_EVMCS_REVISIONS]

Macro Definition Documentation

CC

#define CC   KVM_NESTED_VMENTER_CONSISTENCY_CHECK

Definition at line 14 of file hyperv.c.

pr_fmt

#define pr_fmt

(

fmt

)

KBUILD_MODNAME ": " fmt

Definition at line 2 of file hyperv.c.

Enumeration Type Documentation

evmcs_ctrl_type

enum evmcs_ctrl_type

Enumerator
EVMCS_EXIT_CTRLS
EVMCS_ENTRY_CTRLS
EVMCS_EXEC_CTRL
EVMCS_2NDEXEC
EVMCS_3RDEXEC
EVMCS_PINCTRL
EVMCS_VMFUNC
NR_EVMCS_CTRLS

Definition at line 52 of file hyperv.c.

                     {
    EVMCS_EXIT_CTRLS,
    EVMCS_ENTRY_CTRLS,
    EVMCS_EXEC_CTRL,
    EVMCS_2NDEXEC,
    EVMCS_3RDEXEC,
    EVMCS_PINCTRL,
    EVMCS_VMFUNC,
    NR_EVMCS_CTRLS,
};

evmcs_revision

enum evmcs_revision

Enumerator
EVMCSv1_LEGACY
NR_EVMCS_REVISIONS

Definition at line 47 of file hyperv.c.

                    {
    EVMCSv1_LEGACY,
    NR_EVMCS_REVISIONS,
};

Function Documentation

evmcs_get_supported_ctls()

static u32 evmcs_get_supported_ctls ( enum evmcs_ctrl_type  ctrl_type )

static

Definition at line 87 of file hyperv.c.

{
    enum evmcs_revision evmcs_rev = EVMCSv1_LEGACY;
 
    return evmcs_supported_ctrls[ctrl_type][evmcs_rev];
}

Here is the caller graph for this function:

evmcs_has_perf_global_ctrl()

static bool evmcs_has_perf_global_ctrl ( struct kvm_vcpu *  vcpu )

static

Definition at line 94 of file hyperv.c.

{
    struct kvm_vcpu_hv *hv_vcpu = to_hv_vcpu(vcpu);
 
    /*
     * PERF_GLOBAL_CTRL has a quirk where some Windows guests may fail to
     * boot if a PV CPUID feature flag is not also set.  Treat the fields
     * as unsupported if the flag is not set in guest CPUID.  This should
     * be called only for guest accesses, and all guest accesses should be
     * gated on Hyper-V being enabled and initialized.
     */
    if (WARN_ON_ONCE(!hv_vcpu))
        return false;
 
    return hv_vcpu->cpuid_cache.nested_ebx & HV_X64_NESTED_EVMCS1_PERF_GLOBAL_CTRL;
}

Here is the caller graph for this function:

nested_enable_evmcs()

int nested_enable_evmcs	(	struct kvm_vcpu *	vcpu,
		uint16_t *	vmcs_version
	)

Definition at line 198 of file hyperv.c.

{
    struct vcpu_vmx *vmx = to_vmx(vcpu);
 
    vmx->nested.enlightened_vmcs_enabled = true;
 
    if (vmcs_version)
        *vmcs_version = nested_get_evmcs_version(vcpu);
 
    return 0;
}

Here is the call graph for this function:

nested_evmcs_check_controls()

int nested_evmcs_check_controls

(

struct vmcs12 *

vmcs12

)

Definition at line 161 of file hyperv.c.

{
    if (CC(!nested_evmcs_is_valid_controls(EVMCS_PINCTRL,
                           vmcs12->pin_based_vm_exec_control)))
        return -EINVAL;
 
    if (CC(!nested_evmcs_is_valid_controls(EVMCS_EXEC_CTRL,
                           vmcs12->cpu_based_vm_exec_control)))
        return -EINVAL;
 
    if (CC(!nested_evmcs_is_valid_controls(EVMCS_2NDEXEC,
                           vmcs12->secondary_vm_exec_control)))
        return -EINVAL;
 
    if (CC(!nested_evmcs_is_valid_controls(EVMCS_EXIT_CTRLS,
                           vmcs12->vm_exit_controls)))
        return -EINVAL;
 
    if (CC(!nested_evmcs_is_valid_controls(EVMCS_ENTRY_CTRLS,
                           vmcs12->vm_entry_controls)))
        return -EINVAL;
 
    /*
     * VM-Func controls are 64-bit, but KVM currently doesn't support any
     * controls in bits 63:32, i.e. dropping those bits on the consistency
     * check is intentional.
     */
    if (WARN_ON_ONCE(vmcs12->vm_function_control >> 32))
        return -EINVAL;
 
    if (CC(!nested_evmcs_is_valid_controls(EVMCS_VMFUNC,
                           vmcs12->vm_function_control)))
        return -EINVAL;
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_evmcs_filter_control_msr()

void nested_evmcs_filter_control_msr	(	struct kvm_vcpu *	vcpu,
		u32	msr_index,
		u64 *	pdata
	)

Definition at line 111 of file hyperv.c.

{
    u32 ctl_low = (u32)*pdata;
    u32 ctl_high = (u32)(*pdata >> 32);
    u32 supported_ctrls;
 
    /*
     * Hyper-V 2016 and 2019 try using these features even when eVMCS
     * is enabled but there are no corresponding fields.
     */
    switch (msr_index) {
    case MSR_IA32_VMX_EXIT_CTLS:
    case MSR_IA32_VMX_TRUE_EXIT_CTLS:
        supported_ctrls = evmcs_get_supported_ctls(EVMCS_EXIT_CTRLS);
        if (!evmcs_has_perf_global_ctrl(vcpu))
            supported_ctrls &= ~VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL;
        ctl_high &= supported_ctrls;
        break;
    case MSR_IA32_VMX_ENTRY_CTLS:
    case MSR_IA32_VMX_TRUE_ENTRY_CTLS:
        supported_ctrls = evmcs_get_supported_ctls(EVMCS_ENTRY_CTRLS);
        if (!evmcs_has_perf_global_ctrl(vcpu))
            supported_ctrls &= ~VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL;
        ctl_high &= supported_ctrls;
        break;
    case MSR_IA32_VMX_PROCBASED_CTLS:
    case MSR_IA32_VMX_TRUE_PROCBASED_CTLS:
        ctl_high &= evmcs_get_supported_ctls(EVMCS_EXEC_CTRL);
        break;
    case MSR_IA32_VMX_PROCBASED_CTLS2:
        ctl_high &= evmcs_get_supported_ctls(EVMCS_2NDEXEC);
        break;
    case MSR_IA32_VMX_TRUE_PINBASED_CTLS:
    case MSR_IA32_VMX_PINBASED_CTLS:
        ctl_high &= evmcs_get_supported_ctls(EVMCS_PINCTRL);
        break;
    case MSR_IA32_VMX_VMFUNC:
        ctl_low &= evmcs_get_supported_ctls(EVMCS_VMFUNC);
        break;
    }
 
    *pdata = ctl_low | ((u64)ctl_high << 32);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_evmcs_is_valid_controls()

static bool nested_evmcs_is_valid_controls ( enum evmcs_ctrl_type  ctrl_type, u32  val  )

static

Definition at line 155 of file hyperv.c.

{
    return !(val & ~evmcs_get_supported_ctls(ctrl_type));
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_evmcs_l2_tlb_flush_enabled()

bool nested_evmcs_l2_tlb_flush_enabled

(

struct kvm_vcpu *

vcpu

)

Definition at line 211 of file hyperv.c.

{
    struct kvm_vcpu_hv *hv_vcpu = to_hv_vcpu(vcpu);
    struct vcpu_vmx *vmx = to_vmx(vcpu);
    struct hv_enlightened_vmcs *evmcs = vmx->nested.hv_evmcs;
 
    if (!hv_vcpu || !evmcs)
        return false;
 
    if (!evmcs->hv_enlightenments_control.nested_flush_hypercall)
        return false;
 
    return hv_vcpu->vp_assist_page.nested_control.features.directhypercall;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_get_evmcs_version()

uint16_t nested_get_evmcs_version

(

struct kvm_vcpu *

vcpu

)

Definition at line 29 of file hyperv.c.

{
    /*
     * vmcs_version represents the range of supported Enlightened VMCS
     * versions: lower 8 bits is the minimal version, higher 8 bits is the
     * maximum supported version. KVM supports versions from 1 to
     * KVM_EVMCS_VERSION.
     *
     * Note, do not check the Hyper-V is fully enabled in guest CPUID, this
     * helper is used to _get_ the vCPU's supported CPUID.
     */
    if (kvm_cpu_cap_get(X86_FEATURE_VMX) &&
        (!vcpu || to_vmx(vcpu)->nested.enlightened_vmcs_enabled))
        return (KVM_EVMCS_VERSION << 8) | 1;
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_get_evmptr()

u64 nested_get_evmptr

(

struct kvm_vcpu *

vcpu

)

Definition at line 16 of file hyperv.c.

{
    struct kvm_vcpu_hv *hv_vcpu = to_hv_vcpu(vcpu);
 
    if (unlikely(kvm_hv_get_assist_page(vcpu)))
        return EVMPTR_INVALID;
 
    if (unlikely(!hv_vcpu->vp_assist_page.enlighten_vmentry))
        return EVMPTR_INVALID;
 
    return hv_vcpu->vp_assist_page.current_nested_vmcs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

vmx_hv_inject_synthetic_vmexit_post_tlb_flush()

void vmx_hv_inject_synthetic_vmexit_post_tlb_flush

(

struct kvm_vcpu *

vcpu

)

Definition at line 226 of file hyperv.c.

{
    nested_vmx_vmexit(vcpu, HV_VMX_SYNTHETIC_EXIT_REASON_TRAP_AFTER_FLUSH, 0, 0);
}

Here is the call graph for this function:

Variable Documentation

evmcs_supported_ctrls

const u32 evmcs_supported_ctrls[NR_EVMCS_CTRLS][NR_EVMCS_REVISIONS]

static

Initial value:

= {
    [EVMCS_EXIT_CTRLS] = {
        [EVMCSv1_LEGACY] = EVMCS1_SUPPORTED_VMEXIT_CTRL,
    },
    [EVMCS_ENTRY_CTRLS] = {
        [EVMCSv1_LEGACY] = EVMCS1_SUPPORTED_VMENTRY_CTRL,
    },
    [EVMCS_EXEC_CTRL] = {
        [EVMCSv1_LEGACY] = EVMCS1_SUPPORTED_EXEC_CTRL,
    },
    [EVMCS_2NDEXEC] = {
        [EVMCSv1_LEGACY] = EVMCS1_SUPPORTED_2NDEXEC & ~SECONDARY_EXEC_TSC_SCALING,
    },
    [EVMCS_3RDEXEC] = {
        [EVMCSv1_LEGACY] = EVMCS1_SUPPORTED_3RDEXEC,
    },
    [EVMCS_PINCTRL] = {
        [EVMCSv1_LEGACY] = EVMCS1_SUPPORTED_PINCTRL,
    },
    [EVMCS_VMFUNC] = {
        [EVMCSv1_LEGACY] = EVMCS1_SUPPORTED_VMFUNC,
    },
}

Definition at line 63 of file hyperv.c.