nested.h File Reference

#include "kvm_cache_regs.h"
#include "hyperv.h"
#include "vmcs12.h"
#include "vmx.h"

Include dependency graph for nested.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	nested_guest_cr4_valid   nested_cr4_valid
#define	nested_host_cr4_valid   nested_cr4_valid

Enumerations
enum	nvmx_vmentry_status { NVMX_VMENTRY_SUCCESS , NVMX_VMENTRY_VMFAIL , NVMX_VMENTRY_VMEXIT , NVMX_VMENTRY_KVM_INTERNAL_ERROR }

Functions
void	vmx_leave_nested (struct kvm_vcpu *vcpu)
void	nested_vmx_setup_ctls_msrs (struct vmcs_config *vmcs_conf, u32 ept_caps)
void	nested_vmx_hardware_unsetup (void)
__init int	nested_vmx_hardware_setup (int(*exit_handlers[])(struct kvm_vcpu *))
void	nested_vmx_set_vmcs_shadowing_bitmap (void)
void	nested_vmx_free_vcpu (struct kvm_vcpu *vcpu)
enum nvmx_vmentry_status	nested_vmx_enter_non_root_mode (struct kvm_vcpu *vcpu, bool from_vmentry)
bool	nested_vmx_reflect_vmexit (struct kvm_vcpu *vcpu)
void	nested_vmx_vmexit (struct kvm_vcpu *vcpu, u32 vm_exit_reason, u32 exit_intr_info, unsigned long exit_qualification)
void	nested_sync_vmcs12_to_shadow (struct kvm_vcpu *vcpu)
int	vmx_set_vmx_msr (struct kvm_vcpu *vcpu, u32 msr_index, u64 data)
int	vmx_get_vmx_msr (struct nested_vmx_msrs *msrs, u32 msr_index, u64 *pdata)
int	get_vmx_mem_address (struct kvm_vcpu *vcpu, unsigned long exit_qualification, u32 vmx_instruction_info, bool wr, int len, gva_t *ret)
void	nested_mark_vmcs12_pages_dirty (struct kvm_vcpu *vcpu)
bool	nested_vmx_check_io_bitmaps (struct kvm_vcpu *vcpu, unsigned int port, int size)
static struct vmcs12 *	get_vmcs12 (struct kvm_vcpu *vcpu)
static struct vmcs12 *	get_shadow_vmcs12 (struct kvm_vcpu *vcpu)
static int	vmx_has_valid_vmcs12 (struct kvm_vcpu *vcpu)
static u16	nested_get_vpid02 (struct kvm_vcpu *vcpu)
static unsigned long	nested_ept_get_eptp (struct kvm_vcpu *vcpu)
static bool	nested_ept_ad_enabled (struct kvm_vcpu *vcpu)
static unsigned long	nested_read_cr0 (struct vmcs12 *fields)
static unsigned long	nested_read_cr4 (struct vmcs12 *fields)
static unsigned	nested_cpu_vmx_misc_cr3_count (struct kvm_vcpu *vcpu)
static bool	nested_cpu_has_vmwrite_any_field (struct kvm_vcpu *vcpu)
static bool	nested_cpu_has_zero_length_injection (struct kvm_vcpu *vcpu)
static bool	nested_cpu_supports_monitor_trap_flag (struct kvm_vcpu *vcpu)
static bool	nested_cpu_has_vmx_shadow_vmcs (struct kvm_vcpu *vcpu)
static bool	nested_cpu_has (struct vmcs12 *vmcs12, u32 bit)
static bool	nested_cpu_has2 (struct vmcs12 *vmcs12, u32 bit)
static bool	nested_cpu_has_preemption_timer (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_nmi_exiting (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_virtual_nmis (struct vmcs12 *vmcs12)
static int	nested_cpu_has_mtf (struct vmcs12 *vmcs12)
static int	nested_cpu_has_ept (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_xsaves (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_pml (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_virt_x2apic_mode (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_vpid (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_apic_reg_virt (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_vid (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_posted_intr (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_vmfunc (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_eptp_switching (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_shadow_vmcs (struct vmcs12 *vmcs12)
static bool	nested_cpu_has_save_preemption_timer (struct vmcs12 *vmcs12)
static bool	nested_exit_on_nmi (struct kvm_vcpu *vcpu)
static bool	nested_exit_on_intr (struct kvm_vcpu *vcpu)
static bool	nested_cpu_has_encls_exit (struct vmcs12 *vmcs12)
static bool	fixed_bits_valid (u64 val, u64 fixed0, u64 fixed1)
static bool	nested_guest_cr0_valid (struct kvm_vcpu *vcpu, unsigned long val)
static bool	nested_host_cr0_valid (struct kvm_vcpu *vcpu, unsigned long val)
static bool	nested_cr4_valid (struct kvm_vcpu *vcpu, unsigned long val)

Variables
struct kvm_x86_nested_ops	vmx_nested_ops

Macro Definition Documentation

nested_guest_cr4_valid

#define nested_guest_cr4_valid   nested_cr4_valid

Definition at line 289 of file nested.h.

nested_host_cr4_valid

#define nested_host_cr4_valid   nested_cr4_valid

Definition at line 290 of file nested.h.

Enumeration Type Documentation

nvmx_vmentry_status

enum nvmx_vmentry_status

Enumerator
NVMX_VMENTRY_SUCCESS
NVMX_VMENTRY_VMFAIL
NVMX_VMENTRY_VMEXIT
NVMX_VMENTRY_KVM_INTERNAL_ERROR

Definition at line 13 of file nested.h.

                         {
    NVMX_VMENTRY_SUCCESS,       /* Entered VMX non-root mode */
    NVMX_VMENTRY_VMFAIL,        /* Consistency check VMFail */
    NVMX_VMENTRY_VMEXIT,        /* Consistency check VMExit */
    NVMX_VMENTRY_KVM_INTERNAL_ERROR,/* KVM internal error */
};

Function Documentation

fixed_bits_valid()

static bool fixed_bits_valid ( u64  val, u64  fixed0, u64  fixed1  )

inlinestatic

Definition at line 252 of file nested.h.

{
    return ((val & fixed1) | fixed0) == val;
}

Here is the caller graph for this function:

get_shadow_vmcs12()

static struct vmcs12* get_shadow_vmcs12 ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 45 of file nested.h.

{
    return to_vmx(vcpu)->nested.cached_shadow_vmcs12;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_vmcs12()

static struct vmcs12* get_vmcs12 ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 40 of file nested.h.

{
    return to_vmx(vcpu)->nested.cached_vmcs12;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_vmx_mem_address()

int get_vmx_mem_address	(	struct kvm_vcpu *	vcpu,
		unsigned long	exit_qualification,
		u32	vmx_instruction_info,
		bool	wr,
		int	len,
		gva_t *	ret
	)

Definition at line 4963 of file nested.c.

{
    gva_t off;
    bool exn;
    struct kvm_segment s;
 
    /*
     * According to Vol. 3B, "Information for VM Exits Due to Instruction
     * Execution", on an exit, vmx_instruction_info holds most of the
     * addressing components of the operand. Only the displacement part
     * is put in exit_qualification (see 3B, "Basic VM-Exit Information").
     * For how an actual address is calculated from all these components,
     * refer to Vol. 1, "Operand Addressing".
     */
    int  scaling = vmx_instruction_info & 3;
    int  addr_size = (vmx_instruction_info >> 7) & 7;
    bool is_reg = vmx_instruction_info & (1u << 10);
    int  seg_reg = (vmx_instruction_info >> 15) & 7;
    int  index_reg = (vmx_instruction_info >> 18) & 0xf;
    bool index_is_valid = !(vmx_instruction_info & (1u << 22));
    int  base_reg       = (vmx_instruction_info >> 23) & 0xf;
    bool base_is_valid  = !(vmx_instruction_info & (1u << 27));
 
    if (is_reg) {
        kvm_queue_exception(vcpu, UD_VECTOR);
        return 1;
    }
 
    /* Addr = segment_base + offset */
    /* offset = base + [index * scale] + displacement */
    off = exit_qualification; /* holds the displacement */
    if (addr_size == 1)
        off = (gva_t)sign_extend64(off, 31);
    else if (addr_size == 0)
        off = (gva_t)sign_extend64(off, 15);
    if (base_is_valid)
        off += kvm_register_read(vcpu, base_reg);
    if (index_is_valid)
        off += kvm_register_read(vcpu, index_reg) << scaling;
    vmx_get_segment(vcpu, &s, seg_reg);
 
    /*
     * The effective address, i.e. @off, of a memory operand is truncated
     * based on the address size of the instruction.  Note that this is
     * the *effective address*, i.e. the address prior to accounting for
     * the segment's base.
     */
    if (addr_size == 1) /* 32 bit */
        off &= 0xffffffff;
    else if (addr_size == 0) /* 16 bit */
        off &= 0xffff;
 
    /* Checks for #GP/#SS exceptions. */
    exn = false;
    if (is_long_mode(vcpu)) {
        /*
         * The virtual/linear address is never truncated in 64-bit
         * mode, e.g. a 32-bit address size can yield a 64-bit virtual
         * address when using FS/GS with a non-zero base.
         */
        if (seg_reg == VCPU_SREG_FS || seg_reg == VCPU_SREG_GS)
            *ret = s.base + off;
        else
            *ret = off;
 
        *ret = vmx_get_untagged_addr(vcpu, *ret, 0);
        /* Long mode: #GP(0)/#SS(0) if the memory address is in a
         * non-canonical form. This is the only check on the memory
         * destination for long mode!
         */
        exn = is_noncanonical_address(*ret, vcpu);
    } else {
        /*
         * When not in long mode, the virtual/linear address is
         * unconditionally truncated to 32 bits regardless of the
         * address size.
         */
        *ret = (s.base + off) & 0xffffffff;
 
        /* Protected mode: apply checks for segment validity in the
         * following order:
         * - segment type check (#GP(0) may be thrown)
         * - usability check (#GP(0)/#SS(0))
         * - limit check (#GP(0)/#SS(0))
         */
        if (wr)
            /* #GP(0) if the destination operand is located in a
             * read-only data segment or any code segment.
             */
            exn = ((s.type & 0xa) == 0 || (s.type & 8));
        else
            /* #GP(0) if the source operand is located in an
             * execute-only code segment
             */
            exn = ((s.type & 0xa) == 8);
        if (exn) {
            kvm_queue_exception_e(vcpu, GP_VECTOR, 0);
            return 1;
        }
        /* Protected mode: #GP(0)/#SS(0) if the segment is unusable.
         */
        exn = (s.unusable != 0);
 
        /*
         * Protected mode: #GP(0)/#SS(0) if the memory operand is
         * outside the segment limit.  All CPUs that support VMX ignore
         * limit checks for flat segments, i.e. segments with base==0,
         * limit==0xffffffff and of type expand-up data or code.
         */
        if (!(s.base == 0 && s.limit == 0xffffffff &&
             ((s.type & 8) || !(s.type & 4))))
            exn = exn || ((u64)off + len - 1 > s.limit);
    }
    if (exn) {
        kvm_queue_exception_e(vcpu,
                      seg_reg == VCPU_SREG_SS ?
                        SS_VECTOR : GP_VECTOR,
                      0);
        return 1;
    }
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has()

static bool nested_cpu_has ( struct vmcs12 *  vmcs12, u32  bit  )

inlinestatic

Definition at line 132 of file nested.h.

{
    return vmcs12->cpu_based_vm_exec_control & bit;
}

Here is the caller graph for this function:

nested_cpu_has2()

static bool nested_cpu_has2 ( struct vmcs12 *  vmcs12, u32  bit  )

inlinestatic

Definition at line 137 of file nested.h.

{
    return (vmcs12->cpu_based_vm_exec_control &
            CPU_BASED_ACTIVATE_SECONDARY_CONTROLS) &&
        (vmcs12->secondary_vm_exec_control & bit);
}

Here is the caller graph for this function:

nested_cpu_has_apic_reg_virt()

static bool nested_cpu_has_apic_reg_virt ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 190 of file nested.h.

{
    return nested_cpu_has2(vmcs12, SECONDARY_EXEC_APIC_REGISTER_VIRT);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_encls_exit()

static bool nested_cpu_has_encls_exit ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 243 of file nested.h.

{
    return nested_cpu_has2(vmcs12, SECONDARY_EXEC_ENCLS_EXITING);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_ept()

static int nested_cpu_has_ept ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 165 of file nested.h.

{
    return nested_cpu_has2(vmcs12, SECONDARY_EXEC_ENABLE_EPT);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_eptp_switching()

static bool nested_cpu_has_eptp_switching ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 210 of file nested.h.

{
    return nested_cpu_has_vmfunc(vmcs12) &&
        (vmcs12->vm_function_control &
         VMX_VMFUNC_EPTP_SWITCHING);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_mtf()

static int nested_cpu_has_mtf ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 160 of file nested.h.

{
    return nested_cpu_has(vmcs12, CPU_BASED_MONITOR_TRAP_FLAG);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_nmi_exiting()

static bool nested_cpu_has_nmi_exiting ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 150 of file nested.h.

{
    return vmcs12->pin_based_vm_exec_control & PIN_BASED_NMI_EXITING;
}

Here is the caller graph for this function:

nested_cpu_has_pml()

static bool nested_cpu_has_pml ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 175 of file nested.h.

{
    return nested_cpu_has2(vmcs12, SECONDARY_EXEC_ENABLE_PML);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_posted_intr()

static bool nested_cpu_has_posted_intr ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 200 of file nested.h.

{
    return vmcs12->pin_based_vm_exec_control & PIN_BASED_POSTED_INTR;
}

Here is the caller graph for this function:

nested_cpu_has_preemption_timer()

static bool nested_cpu_has_preemption_timer ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 144 of file nested.h.

{
    return vmcs12->pin_based_vm_exec_control &
        PIN_BASED_VMX_PREEMPTION_TIMER;
}

Here is the caller graph for this function:

nested_cpu_has_save_preemption_timer()

static bool nested_cpu_has_save_preemption_timer ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 222 of file nested.h.

{
    return vmcs12->vm_exit_controls &
        VM_EXIT_SAVE_VMX_PREEMPTION_TIMER;
}

Here is the caller graph for this function:

nested_cpu_has_shadow_vmcs()

static bool nested_cpu_has_shadow_vmcs ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 217 of file nested.h.

{
    return nested_cpu_has2(vmcs12, SECONDARY_EXEC_SHADOW_VMCS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_vid()

static bool nested_cpu_has_vid ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 195 of file nested.h.

{
    return nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_virt_x2apic_mode()

static bool nested_cpu_has_virt_x2apic_mode ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 180 of file nested.h.

{
    return nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_virtual_nmis()

static bool nested_cpu_has_virtual_nmis ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 155 of file nested.h.

{
    return vmcs12->pin_based_vm_exec_control & PIN_BASED_VIRTUAL_NMIS;
}

Here is the caller graph for this function:

nested_cpu_has_vmfunc()

static bool nested_cpu_has_vmfunc ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 205 of file nested.h.

{
    return nested_cpu_has2(vmcs12, SECONDARY_EXEC_ENABLE_VMFUNC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_vmwrite_any_field()

static bool nested_cpu_has_vmwrite_any_field ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 109 of file nested.h.

{
    return to_vmx(vcpu)->nested.msrs.misc_low &
        MSR_IA32_VMX_MISC_VMWRITE_SHADOW_RO_FIELDS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_vmx_shadow_vmcs()

static bool nested_cpu_has_vmx_shadow_vmcs ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 126 of file nested.h.

{
    return to_vmx(vcpu)->nested.msrs.secondary_ctls_high &
        SECONDARY_EXEC_SHADOW_VMCS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_vpid()

static bool nested_cpu_has_vpid ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 185 of file nested.h.

{
    return nested_cpu_has2(vmcs12, SECONDARY_EXEC_ENABLE_VPID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_xsaves()

static bool nested_cpu_has_xsaves ( struct vmcs12 *  vmcs12 )

inlinestatic

Definition at line 170 of file nested.h.

{
    return nested_cpu_has2(vmcs12, SECONDARY_EXEC_ENABLE_XSAVES);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_has_zero_length_injection()

static bool nested_cpu_has_zero_length_injection ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 115 of file nested.h.

{
    return to_vmx(vcpu)->nested.msrs.misc_low & VMX_MISC_ZERO_LEN_INS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_supports_monitor_trap_flag()

static bool nested_cpu_supports_monitor_trap_flag ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 120 of file nested.h.

{
    return to_vmx(vcpu)->nested.msrs.procbased_ctls_high &
            CPU_BASED_MONITOR_TRAP_FLAG;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cpu_vmx_misc_cr3_count()

static unsigned nested_cpu_vmx_misc_cr3_count ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 99 of file nested.h.

{
    return vmx_misc_cr3_count(to_vmx(vcpu)->nested.msrs.misc_low);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_cr4_valid()

static bool nested_cr4_valid ( struct kvm_vcpu *  vcpu, unsigned long  val  )

inlinestatic

Definition at line 279 of file nested.h.

{
    u64 fixed0 = to_vmx(vcpu)->nested.msrs.cr4_fixed0;
    u64 fixed1 = to_vmx(vcpu)->nested.msrs.cr4_fixed1;
 
    return fixed_bits_valid(val, fixed0, fixed1) &&
           __kvm_is_valid_cr4(vcpu, val);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_ept_ad_enabled()

static bool nested_ept_ad_enabled ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 77 of file nested.h.

{
    return nested_ept_get_eptp(vcpu) & VMX_EPTP_AD_ENABLE_BIT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_ept_get_eptp()

static unsigned long nested_ept_get_eptp ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 71 of file nested.h.

{
    /* return the page table to be shadowed - in our case, EPT12 */
    return get_vmcs12(vcpu)->ept_pointer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_exit_on_intr()

static bool nested_exit_on_intr ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 237 of file nested.h.

{
    return get_vmcs12(vcpu)->pin_based_vm_exec_control &
        PIN_BASED_EXT_INTR_MASK;
}

Here is the call graph for this function:

nested_exit_on_nmi()

static bool nested_exit_on_nmi ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 228 of file nested.h.

{
    return nested_cpu_has_nmi_exiting(get_vmcs12(vcpu));
}

Here is the call graph for this function:

nested_get_vpid02()

static u16 nested_get_vpid02 ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 64 of file nested.h.

{
    struct vcpu_vmx *vmx = to_vmx(vcpu);
 
    return vmx->nested.vpid02 ? vmx->nested.vpid02 : vmx->vpid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_guest_cr0_valid()

static bool nested_guest_cr0_valid ( struct kvm_vcpu *  vcpu, unsigned long  val  )

inlinestatic

Definition at line 257 of file nested.h.

{
    u64 fixed0 = to_vmx(vcpu)->nested.msrs.cr0_fixed0;
    u64 fixed1 = to_vmx(vcpu)->nested.msrs.cr0_fixed1;
    struct vmcs12 *vmcs12 = get_vmcs12(vcpu);
 
    if (to_vmx(vcpu)->nested.msrs.secondary_ctls_high &
        SECONDARY_EXEC_UNRESTRICTED_GUEST &&
        nested_cpu_has2(vmcs12, SECONDARY_EXEC_UNRESTRICTED_GUEST))
        fixed0 &= ~(X86_CR0_PE | X86_CR0_PG);
 
    return fixed_bits_valid(val, fixed0, fixed1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_host_cr0_valid()

static bool nested_host_cr0_valid ( struct kvm_vcpu *  vcpu, unsigned long  val  )

inlinestatic

Definition at line 271 of file nested.h.

{
    u64 fixed0 = to_vmx(vcpu)->nested.msrs.cr0_fixed0;
    u64 fixed1 = to_vmx(vcpu)->nested.msrs.cr0_fixed1;
 
    return fixed_bits_valid(val, fixed0, fixed1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_mark_vmcs12_pages_dirty()

void nested_mark_vmcs12_pages_dirty

(

struct kvm_vcpu *

vcpu

)

Definition at line 3838 of file nested.c.

{
    struct vmcs12 *vmcs12 = get_vmcs12(vcpu);
    gfn_t gfn;
 
    /*
     * Don't need to mark the APIC access page dirty; it is never
     * written to by the CPU during APIC virtualization.
     */
 
    if (nested_cpu_has(vmcs12, CPU_BASED_TPR_SHADOW)) {
        gfn = vmcs12->virtual_apic_page_addr >> PAGE_SHIFT;
        kvm_vcpu_mark_page_dirty(vcpu, gfn);
    }
 
    if (nested_cpu_has_posted_intr(vmcs12)) {
        gfn = vmcs12->posted_intr_desc_addr >> PAGE_SHIFT;
        kvm_vcpu_mark_page_dirty(vcpu, gfn);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_read_cr0()

static unsigned long nested_read_cr0 ( struct vmcs12 *  fields )

inlinestatic

Definition at line 88 of file nested.h.

{
    return (fields->guest_cr0 & ~fields->cr0_guest_host_mask) |
        (fields->cr0_read_shadow & fields->cr0_guest_host_mask);
}

Here is the caller graph for this function:

nested_read_cr4()

static unsigned long nested_read_cr4 ( struct vmcs12 *  fields )

inlinestatic

Definition at line 93 of file nested.h.

{
    return (fields->guest_cr4 & ~fields->cr4_guest_host_mask) |
        (fields->cr4_read_shadow & fields->cr4_guest_host_mask);
}

Here is the caller graph for this function:

nested_sync_vmcs12_to_shadow()

void nested_sync_vmcs12_to_shadow

(

struct kvm_vcpu *

vcpu

)

Definition at line 2124 of file nested.c.

{
    struct vcpu_vmx *vmx = to_vmx(vcpu);
 
    if (nested_vmx_is_evmptr12_valid(vmx))
        copy_vmcs12_to_enlightened(vmx);
    else
        copy_vmcs12_to_shadow(vmx);
 
    vmx->nested.need_vmcs12_to_shadow_sync = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_vmx_check_io_bitmaps()

bool nested_vmx_check_io_bitmaps	(	struct kvm_vcpu *	vcpu,
		unsigned int	port,
		int	size
	)

Definition at line 5963 of file nested.c.

{
    struct vmcs12 *vmcs12 = get_vmcs12(vcpu);
    gpa_t bitmap, last_bitmap;
    u8 b;
 
    last_bitmap = INVALID_GPA;
    b = -1;
 
    while (size > 0) {
        if (port < 0x8000)
            bitmap = vmcs12->io_bitmap_a;
        else if (port < 0x10000)
            bitmap = vmcs12->io_bitmap_b;
        else
            return true;
        bitmap += (port & 0x7fff) / 8;
 
        if (last_bitmap != bitmap)
            if (kvm_vcpu_read_guest(vcpu, bitmap, &b, 1))
                return true;
        if (b & (1 << (port & 7)))
            return true;
 
        port++;
        size--;
        last_bitmap = bitmap;
    }
 
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_vmx_enter_non_root_mode()

enum nvmx_vmentry_status nested_vmx_enter_non_root_mode	(	struct kvm_vcpu *	vcpu,
		bool	from_vmentry
	)

Definition at line 3414 of file nested.c.

{
    struct vcpu_vmx *vmx = to_vmx(vcpu);
    struct vmcs12 *vmcs12 = get_vmcs12(vcpu);
    enum vm_entry_failure_code entry_failure_code;
    bool evaluate_pending_interrupts;
    union vmx_exit_reason exit_reason = {
        .basic = EXIT_REASON_INVALID_STATE,
        .failed_vmentry = 1,
    };
    u32 failed_index;
 
    trace_kvm_nested_vmenter(kvm_rip_read(vcpu),
                 vmx->nested.current_vmptr,
                 vmcs12->guest_rip,
                 vmcs12->guest_intr_status,
                 vmcs12->vm_entry_intr_info_field,
                 vmcs12->secondary_vm_exec_control & SECONDARY_EXEC_ENABLE_EPT,
                 vmcs12->ept_pointer,
                 vmcs12->guest_cr3,
                 KVM_ISA_VMX);
 
    kvm_service_local_tlb_flush_requests(vcpu);
 
    evaluate_pending_interrupts = exec_controls_get(vmx) &
        (CPU_BASED_INTR_WINDOW_EXITING | CPU_BASED_NMI_WINDOW_EXITING);
    if (likely(!evaluate_pending_interrupts) && kvm_vcpu_apicv_active(vcpu))
        evaluate_pending_interrupts |= vmx_has_apicv_interrupt(vcpu);
    if (!evaluate_pending_interrupts)
        evaluate_pending_interrupts |= kvm_apic_has_pending_init_or_sipi(vcpu);
 
    if (!vmx->nested.nested_run_pending ||
        !(vmcs12->vm_entry_controls & VM_ENTRY_LOAD_DEBUG_CONTROLS))
        vmx->nested.pre_vmenter_debugctl = vmcs_read64(GUEST_IA32_DEBUGCTL);
    if (kvm_mpx_supported() &&
        (!vmx->nested.nested_run_pending ||
         !(vmcs12->vm_entry_controls & VM_ENTRY_LOAD_BNDCFGS)))
        vmx->nested.pre_vmenter_bndcfgs = vmcs_read64(GUEST_BNDCFGS);
 
    /*
     * Overwrite vmcs01.GUEST_CR3 with L1's CR3 if EPT is disabled *and*
     * nested early checks are disabled.  In the event of a "late" VM-Fail,
     * i.e. a VM-Fail detected by hardware but not KVM, KVM must unwind its
     * software model to the pre-VMEntry host state.  When EPT is disabled,
     * GUEST_CR3 holds KVM's shadow CR3, not L1's "real" CR3, which causes
     * nested_vmx_restore_host_state() to corrupt vcpu->arch.cr3.  Stuffing
     * vmcs01.GUEST_CR3 results in the unwind naturally setting arch.cr3 to
     * the correct value.  Smashing vmcs01.GUEST_CR3 is safe because nested
     * VM-Exits, and the unwind, reset KVM's MMU, i.e. vmcs01.GUEST_CR3 is
     * guaranteed to be overwritten with a shadow CR3 prior to re-entering
     * L1.  Don't stuff vmcs01.GUEST_CR3 when using nested early checks as
     * KVM modifies vcpu->arch.cr3 if and only if the early hardware checks
     * pass, and early VM-Fails do not reset KVM's MMU, i.e. the VM-Fail
     * path would need to manually save/restore vmcs01.GUEST_CR3.
     */
    if (!enable_ept && !nested_early_check)
        vmcs_writel(GUEST_CR3, vcpu->arch.cr3);
 
    vmx_switch_vmcs(vcpu, &vmx->nested.vmcs02);
 
    prepare_vmcs02_early(vmx, &vmx->vmcs01, vmcs12);
 
    if (from_vmentry) {
        if (unlikely(!nested_get_vmcs12_pages(vcpu))) {
            vmx_switch_vmcs(vcpu, &vmx->vmcs01);
            return NVMX_VMENTRY_KVM_INTERNAL_ERROR;
        }
 
        if (nested_vmx_check_vmentry_hw(vcpu)) {
            vmx_switch_vmcs(vcpu, &vmx->vmcs01);
            return NVMX_VMENTRY_VMFAIL;
        }
 
        if (nested_vmx_check_guest_state(vcpu, vmcs12,
                         &entry_failure_code)) {
            exit_reason.basic = EXIT_REASON_INVALID_STATE;
            vmcs12->exit_qualification = entry_failure_code;
            goto vmentry_fail_vmexit;
        }
    }
 
    enter_guest_mode(vcpu);
 
    if (prepare_vmcs02(vcpu, vmcs12, from_vmentry, &entry_failure_code)) {
        exit_reason.basic = EXIT_REASON_INVALID_STATE;
        vmcs12->exit_qualification = entry_failure_code;
        goto vmentry_fail_vmexit_guest_mode;
    }
 
    if (from_vmentry) {
        failed_index = nested_vmx_load_msr(vcpu,
                           vmcs12->vm_entry_msr_load_addr,
                           vmcs12->vm_entry_msr_load_count);
        if (failed_index) {
            exit_reason.basic = EXIT_REASON_MSR_LOAD_FAIL;
            vmcs12->exit_qualification = failed_index;
            goto vmentry_fail_vmexit_guest_mode;
        }
    } else {
        /*
         * The MMU is not initialized to point at the right entities yet and
         * "get pages" would need to read data from the guest (i.e. we will
         * need to perform gpa to hpa translation). Request a call
         * to nested_get_vmcs12_pages before the next VM-entry.  The MSRs
         * have already been set at vmentry time and should not be reset.
         */
        kvm_make_request(KVM_REQ_GET_NESTED_STATE_PAGES, vcpu);
    }
 
    /*
     * Re-evaluate pending events if L1 had a pending IRQ/NMI/INIT/SIPI
     * when it executed VMLAUNCH/VMRESUME, as entering non-root mode can
     * effectively unblock various events, e.g. INIT/SIPI cause VM-Exit
     * unconditionally.
     */
    if (unlikely(evaluate_pending_interrupts))
        kvm_make_request(KVM_REQ_EVENT, vcpu);
 
    /*
     * Do not start the preemption timer hrtimer until after we know
     * we are successful, so that only nested_vmx_vmexit needs to cancel
     * the timer.
     */
    vmx->nested.preemption_timer_expired = false;
    if (nested_cpu_has_preemption_timer(vmcs12)) {
        u64 timer_value = vmx_calc_preemption_timer_value(vcpu);
        vmx_start_preemption_timer(vcpu, timer_value);
    }
 
    /*
     * Note no nested_vmx_succeed or nested_vmx_fail here. At this point
     * we are no longer running L1, and VMLAUNCH/VMRESUME has not yet
     * returned as far as L1 is concerned. It will only return (and set
     * the success flag) when L2 exits (see nested_vmx_vmexit()).
     */
    return NVMX_VMENTRY_SUCCESS;
 
    /*
     * A failed consistency check that leads to a VMExit during L1's
     * VMEnter to L2 is a variation of a normal VMexit, as explained in
     * 26.7 "VM-entry failures during or after loading guest state".
     */
vmentry_fail_vmexit_guest_mode:
    if (vmcs12->cpu_based_vm_exec_control & CPU_BASED_USE_TSC_OFFSETTING)
        vcpu->arch.tsc_offset -= vmcs12->tsc_offset;
    leave_guest_mode(vcpu);
 
vmentry_fail_vmexit:
    vmx_switch_vmcs(vcpu, &vmx->vmcs01);
 
    if (!from_vmentry)
        return NVMX_VMENTRY_VMEXIT;
 
    load_vmcs12_host_state(vcpu, vmcs12);
    vmcs12->vm_exit_reason = exit_reason.full;
    if (enable_shadow_vmcs || nested_vmx_is_evmptr12_valid(vmx))
        vmx->nested.need_vmcs12_to_shadow_sync = true;
    return NVMX_VMENTRY_VMEXIT;
}

Here is the caller graph for this function:

nested_vmx_free_vcpu()

void nested_vmx_free_vcpu

(

struct kvm_vcpu *

vcpu

)

Definition at line 372 of file nested.c.

{
    vcpu_load(vcpu);
    vmx_leave_nested(vcpu);
    vcpu_put(vcpu);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_vmx_hardware_setup()

__init int nested_vmx_hardware_setup

(

int(*[])(struct kvm_vcpu *)

exit_handlers

)

Definition at line 7092 of file nested.c.

{
    int i;
 
    if (!cpu_has_vmx_shadow_vmcs())
        enable_shadow_vmcs = 0;
    if (enable_shadow_vmcs) {
        for (i = 0; i < VMX_BITMAP_NR; i++) {
            /*
             * The vmx_bitmap is not tied to a VM and so should
             * not be charged to a memcg.
             */
            vmx_bitmap[i] = (unsigned long *)
                __get_free_page(GFP_KERNEL);
            if (!vmx_bitmap[i]) {
                nested_vmx_hardware_unsetup();
                return -ENOMEM;
            }
        }
 
        init_vmcs_shadow_fields();
    }
 
    exit_handlers[EXIT_REASON_VMCLEAR]  = handle_vmclear;
    exit_handlers[EXIT_REASON_VMLAUNCH] = handle_vmlaunch;
    exit_handlers[EXIT_REASON_VMPTRLD]  = handle_vmptrld;
    exit_handlers[EXIT_REASON_VMPTRST]  = handle_vmptrst;
    exit_handlers[EXIT_REASON_VMREAD]   = handle_vmread;
    exit_handlers[EXIT_REASON_VMRESUME] = handle_vmresume;
    exit_handlers[EXIT_REASON_VMWRITE]  = handle_vmwrite;
    exit_handlers[EXIT_REASON_VMOFF]    = handle_vmxoff;
    exit_handlers[EXIT_REASON_VMON]     = handle_vmxon;
    exit_handlers[EXIT_REASON_INVEPT]   = handle_invept;
    exit_handlers[EXIT_REASON_INVVPID]  = handle_invvpid;
    exit_handlers[EXIT_REASON_VMFUNC]   = handle_vmfunc;
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_vmx_hardware_unsetup()

void nested_vmx_hardware_unsetup

(

void

)

Definition at line 7082 of file nested.c.

{
    int i;
 
    if (enable_shadow_vmcs) {
        for (i = 0; i < VMX_BITMAP_NR; i++)
            free_page((unsigned long)vmx_bitmap[i]);
    }
}

Here is the caller graph for this function:

nested_vmx_reflect_vmexit()

bool nested_vmx_reflect_vmexit

(

struct kvm_vcpu *

vcpu

)

Definition at line 6393 of file nested.c.

{
    struct vcpu_vmx *vmx = to_vmx(vcpu);
    union vmx_exit_reason exit_reason = vmx->exit_reason;
    unsigned long exit_qual;
    u32 exit_intr_info;
 
    WARN_ON_ONCE(vmx->nested.nested_run_pending);
 
    /*
     * Late nested VM-Fail shares the same flow as nested VM-Exit since KVM
     * has already loaded L2's state.
     */
    if (unlikely(vmx->fail)) {
        trace_kvm_nested_vmenter_failed(
            "hardware VM-instruction error: ",
            vmcs_read32(VM_INSTRUCTION_ERROR));
        exit_intr_info = 0;
        exit_qual = 0;
        goto reflect_vmexit;
    }
 
    trace_kvm_nested_vmexit(vcpu, KVM_ISA_VMX);
 
    /* If L0 (KVM) wants the exit, it trumps L1's desires. */
    if (nested_vmx_l0_wants_exit(vcpu, exit_reason))
        return false;
 
    /* If L1 doesn't want the exit, handle it in L0. */
    if (!nested_vmx_l1_wants_exit(vcpu, exit_reason))
        return false;
 
    /*
     * vmcs.VM_EXIT_INTR_INFO is only valid for EXCEPTION_NMI exits.  For
     * EXTERNAL_INTERRUPT, the value for vmcs12->vm_exit_intr_info would
     * need to be synthesized by querying the in-kernel LAPIC, but external
     * interrupts are never reflected to L1 so it's a non-issue.
     */
    exit_intr_info = vmx_get_intr_info(vcpu);
    if (is_exception_with_error_code(exit_intr_info)) {
        struct vmcs12 *vmcs12 = get_vmcs12(vcpu);
 
        vmcs12->vm_exit_intr_error_code =
            vmcs_read32(VM_EXIT_INTR_ERROR_CODE);
    }
    exit_qual = vmx_get_exit_qual(vcpu);
 
reflect_vmexit:
    nested_vmx_vmexit(vcpu, exit_reason.full, exit_intr_info, exit_qual);
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_vmx_set_vmcs_shadowing_bitmap()

void nested_vmx_set_vmcs_shadowing_bitmap

(

void

)

Definition at line 6764 of file nested.c.

{
    if (enable_shadow_vmcs) {
        vmcs_write64(VMREAD_BITMAP, __pa(vmx_vmread_bitmap));
        vmcs_write64(VMWRITE_BITMAP, __pa(vmx_vmwrite_bitmap));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_vmx_setup_ctls_msrs()

void nested_vmx_setup_ctls_msrs	(	struct vmcs_config *	vmcs_conf,
		u32	ept_caps
	)

Definition at line 7045 of file nested.c.

{
    struct nested_vmx_msrs *msrs = &vmcs_conf->nested;
 
    /*
     * Note that as a general rule, the high half of the MSRs (bits in
     * the control fields which may be 1) should be initialized by the
     * intersection of the underlying hardware's MSR (i.e., features which
     * can be supported) and the list of features we want to expose -
     * because they are known to be properly supported in our code.
     * Also, usually, the low half of the MSRs (bits which must be 1) can
     * be set to 0, meaning that L1 may turn off any of these bits. The
     * reason is that if one of these bits is necessary, it will appear
     * in vmcs01 and prepare_vmcs02, when it bitwise-or's the control
     * fields of vmcs01 and vmcs02, will turn these bits off - and
     * nested_vmx_l1_wants_exit() will not pass related exits to L1.
     * These rules have exceptions below.
     */
    nested_vmx_setup_pinbased_ctls(vmcs_conf, msrs);
 
    nested_vmx_setup_exit_ctls(vmcs_conf, msrs);
 
    nested_vmx_setup_entry_ctls(vmcs_conf, msrs);
 
    nested_vmx_setup_cpubased_ctls(vmcs_conf, msrs);
 
    nested_vmx_setup_secondary_ctls(ept_caps, vmcs_conf, msrs);
 
    nested_vmx_setup_misc_data(vmcs_conf, msrs);
 
    nested_vmx_setup_basic(msrs);
 
    nested_vmx_setup_cr_fixed(msrs);
 
    msrs->vmcs_enum = nested_vmx_calc_vmcs_enum_msr();
}

Here is the call graph for this function:

Here is the caller graph for this function:

nested_vmx_vmexit()

void nested_vmx_vmexit	(	struct kvm_vcpu *	vcpu,
		u32	vm_exit_reason,
		u32	exit_intr_info,
		unsigned long	exit_qualification
	)

Definition at line 4767 of file nested.c.

{
    struct vcpu_vmx *vmx = to_vmx(vcpu);
    struct vmcs12 *vmcs12 = get_vmcs12(vcpu);
 
    /* Pending MTF traps are discarded on VM-Exit. */
    vmx->nested.mtf_pending = false;
 
    /* trying to cancel vmlaunch/vmresume is a bug */
    WARN_ON_ONCE(vmx->nested.nested_run_pending);
 
#ifdef CONFIG_KVM_HYPERV
    if (kvm_check_request(KVM_REQ_GET_NESTED_STATE_PAGES, vcpu)) {
        /*
         * KVM_REQ_GET_NESTED_STATE_PAGES is also used to map
         * Enlightened VMCS after migration and we still need to
         * do that when something is forcing L2->L1 exit prior to
         * the first L2 run.
         */
        (void)nested_get_evmcs_page(vcpu);
    }
#endif
 
    /* Service pending TLB flush requests for L2 before switching to L1. */
    kvm_service_local_tlb_flush_requests(vcpu);
 
    /*
     * VCPU_EXREG_PDPTR will be clobbered in arch/x86/kvm/vmx/vmx.h between
     * now and the new vmentry.  Ensure that the VMCS02 PDPTR fields are
     * up-to-date before switching to L1.
     */
    if (enable_ept && is_pae_paging(vcpu))
        vmx_ept_load_pdptrs(vcpu);
 
    leave_guest_mode(vcpu);
 
    if (nested_cpu_has_preemption_timer(vmcs12))
        hrtimer_cancel(&to_vmx(vcpu)->nested.preemption_timer);
 
    if (nested_cpu_has(vmcs12, CPU_BASED_USE_TSC_OFFSETTING)) {
        vcpu->arch.tsc_offset = vcpu->arch.l1_tsc_offset;
        if (nested_cpu_has2(vmcs12, SECONDARY_EXEC_TSC_SCALING))
            vcpu->arch.tsc_scaling_ratio = vcpu->arch.l1_tsc_scaling_ratio;
    }
 
    if (likely(!vmx->fail)) {
        sync_vmcs02_to_vmcs12(vcpu, vmcs12);
 
        if (vm_exit_reason != -1)
            prepare_vmcs12(vcpu, vmcs12, vm_exit_reason,
                       exit_intr_info, exit_qualification);
 
        /*
         * Must happen outside of sync_vmcs02_to_vmcs12() as it will
         * also be used to capture vmcs12 cache as part of
         * capturing nVMX state for snapshot (migration).
         *
         * Otherwise, this flush will dirty guest memory at a
         * point it is already assumed by user-space to be
         * immutable.
         */
        nested_flush_cached_shadow_vmcs12(vcpu, vmcs12);
    } else {
        /*
         * The only expected VM-instruction error is "VM entry with
         * invalid control field(s)." Anything else indicates a
         * problem with L0.  And we should never get here with a
         * VMFail of any type if early consistency checks are enabled.
         */
        WARN_ON_ONCE(vmcs_read32(VM_INSTRUCTION_ERROR) !=
                 VMXERR_ENTRY_INVALID_CONTROL_FIELD);
        WARN_ON_ONCE(nested_early_check);
    }
 
    /*
     * Drop events/exceptions that were queued for re-injection to L2
     * (picked up via vmx_complete_interrupts()), as well as exceptions
     * that were pending for L2.  Note, this must NOT be hoisted above
     * prepare_vmcs12(), events/exceptions queued for re-injection need to
     * be captured in vmcs12 (see vmcs12_save_pending_event()).
     */
    vcpu->arch.nmi_injected = false;
    kvm_clear_exception_queue(vcpu);
    kvm_clear_interrupt_queue(vcpu);
 
    vmx_switch_vmcs(vcpu, &vmx->vmcs01);
 
    /*
     * If IBRS is advertised to the vCPU, KVM must flush the indirect
     * branch predictors when transitioning from L2 to L1, as L1 expects
     * hardware (KVM in this case) to provide separate predictor modes.
     * Bare metal isolates VMX root (host) from VMX non-root (guest), but
     * doesn't isolate different VMCSs, i.e. in this case, doesn't provide
     * separate modes for L2 vs L1.
     */
    if (guest_cpuid_has(vcpu, X86_FEATURE_SPEC_CTRL))
        indirect_branch_prediction_barrier();
 
    /* Update any VMCS fields that might have changed while L2 ran */
    vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, vmx->msr_autoload.host.nr);
    vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, vmx->msr_autoload.guest.nr);
    vmcs_write64(TSC_OFFSET, vcpu->arch.tsc_offset);
    if (kvm_caps.has_tsc_control)
        vmcs_write64(TSC_MULTIPLIER, vcpu->arch.tsc_scaling_ratio);
 
    if (vmx->nested.l1_tpr_threshold != -1)
        vmcs_write32(TPR_THRESHOLD, vmx->nested.l1_tpr_threshold);
 
    if (vmx->nested.change_vmcs01_virtual_apic_mode) {
        vmx->nested.change_vmcs01_virtual_apic_mode = false;
        vmx_set_virtual_apic_mode(vcpu);
    }
 
    if (vmx->nested.update_vmcs01_cpu_dirty_logging) {
        vmx->nested.update_vmcs01_cpu_dirty_logging = false;
        vmx_update_cpu_dirty_logging(vcpu);
    }
 
    /* Unpin physical memory we referred to in vmcs02 */
    kvm_vcpu_unmap(vcpu, &vmx->nested.apic_access_page_map, false);
    kvm_vcpu_unmap(vcpu, &vmx->nested.virtual_apic_map, true);
    kvm_vcpu_unmap(vcpu, &vmx->nested.pi_desc_map, true);
    vmx->nested.pi_desc = NULL;
 
    if (vmx->nested.reload_vmcs01_apic_access_page) {
        vmx->nested.reload_vmcs01_apic_access_page = false;
        kvm_make_request(KVM_REQ_APIC_PAGE_RELOAD, vcpu);
    }
 
    if (vmx->nested.update_vmcs01_apicv_status) {
        vmx->nested.update_vmcs01_apicv_status = false;
        kvm_make_request(KVM_REQ_APICV_UPDATE, vcpu);
    }
 
    if ((vm_exit_reason != -1) &&
        (enable_shadow_vmcs || nested_vmx_is_evmptr12_valid(vmx)))
        vmx->nested.need_vmcs12_to_shadow_sync = true;
 
    /* in case we halted in L2 */
    vcpu->arch.mp_state = KVM_MP_STATE_RUNNABLE;
 
    if (likely(!vmx->fail)) {
        if ((u16)vm_exit_reason == EXIT_REASON_EXTERNAL_INTERRUPT &&
            nested_exit_intr_ack_set(vcpu)) {
            int irq = kvm_cpu_get_interrupt(vcpu);
            WARN_ON(irq < 0);
            vmcs12->vm_exit_intr_info = irq |
                INTR_INFO_VALID_MASK | INTR_TYPE_EXT_INTR;
        }
 
        if (vm_exit_reason != -1)
            trace_kvm_nested_vmexit_inject(vmcs12->vm_exit_reason,
                               vmcs12->exit_qualification,
                               vmcs12->idt_vectoring_info_field,
                               vmcs12->vm_exit_intr_info,
                               vmcs12->vm_exit_intr_error_code,
                               KVM_ISA_VMX);
 
        load_vmcs12_host_state(vcpu, vmcs12);
 
        return;
    }
 
    /*
     * After an early L2 VM-entry failure, we're now back
     * in L1 which thinks it just finished a VMLAUNCH or
     * VMRESUME instruction, so we need to set the failure
     * flag and the VM-instruction error field of the VMCS
     * accordingly, and skip the emulated instruction.
     */
    (void)nested_vmx_fail(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD);
 
    /*
     * Restore L1's host state to KVM's software model.  We're here
     * because a consistency check was caught by hardware, which
     * means some amount of guest state has been propagated to KVM's
     * model and needs to be unwound to the host's state.
     */
    nested_vmx_restore_host_state(vcpu);
 
    vmx->fail = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

vmx_get_vmx_msr()

int vmx_get_vmx_msr	(	struct nested_vmx_msrs *	msrs,
		u32	msr_index,
		u64 *	pdata
	)

Definition at line 1458 of file nested.c.

{
    switch (msr_index) {
    case MSR_IA32_VMX_BASIC:
        *pdata = msrs->basic;
        break;
    case MSR_IA32_VMX_TRUE_PINBASED_CTLS:
    case MSR_IA32_VMX_PINBASED_CTLS:
        *pdata = vmx_control_msr(
            msrs->pinbased_ctls_low,
            msrs->pinbased_ctls_high);
        if (msr_index == MSR_IA32_VMX_PINBASED_CTLS)
            *pdata |= PIN_BASED_ALWAYSON_WITHOUT_TRUE_MSR;
        break;
    case MSR_IA32_VMX_TRUE_PROCBASED_CTLS:
    case MSR_IA32_VMX_PROCBASED_CTLS:
        *pdata = vmx_control_msr(
            msrs->procbased_ctls_low,
            msrs->procbased_ctls_high);
        if (msr_index == MSR_IA32_VMX_PROCBASED_CTLS)
            *pdata |= CPU_BASED_ALWAYSON_WITHOUT_TRUE_MSR;
        break;
    case MSR_IA32_VMX_TRUE_EXIT_CTLS:
    case MSR_IA32_VMX_EXIT_CTLS:
        *pdata = vmx_control_msr(
            msrs->exit_ctls_low,
            msrs->exit_ctls_high);
        if (msr_index == MSR_IA32_VMX_EXIT_CTLS)
            *pdata |= VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR;
        break;
    case MSR_IA32_VMX_TRUE_ENTRY_CTLS:
    case MSR_IA32_VMX_ENTRY_CTLS:
        *pdata = vmx_control_msr(
            msrs->entry_ctls_low,
            msrs->entry_ctls_high);
        if (msr_index == MSR_IA32_VMX_ENTRY_CTLS)
            *pdata |= VM_ENTRY_ALWAYSON_WITHOUT_TRUE_MSR;
        break;
    case MSR_IA32_VMX_MISC:
        *pdata = vmx_control_msr(
            msrs->misc_low,
            msrs->misc_high);
        break;
    case MSR_IA32_VMX_CR0_FIXED0:
        *pdata = msrs->cr0_fixed0;
        break;
    case MSR_IA32_VMX_CR0_FIXED1:
        *pdata = msrs->cr0_fixed1;
        break;
    case MSR_IA32_VMX_CR4_FIXED0:
        *pdata = msrs->cr4_fixed0;
        break;
    case MSR_IA32_VMX_CR4_FIXED1:
        *pdata = msrs->cr4_fixed1;
        break;
    case MSR_IA32_VMX_VMCS_ENUM:
        *pdata = msrs->vmcs_enum;
        break;
    case MSR_IA32_VMX_PROCBASED_CTLS2:
        *pdata = vmx_control_msr(
            msrs->secondary_ctls_low,
            msrs->secondary_ctls_high);
        break;
    case MSR_IA32_VMX_EPT_VPID_CAP:
        *pdata = msrs->ept_caps |
            ((u64)msrs->vpid_caps << 32);
        break;
    case MSR_IA32_VMX_VMFUNC:
        *pdata = msrs->vmfunc_controls;
        break;
    default:
        return 1;
    }
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

vmx_has_valid_vmcs12()

static int vmx_has_valid_vmcs12 ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 55 of file nested.h.

{
    struct vcpu_vmx *vmx = to_vmx(vcpu);
 
    /* 'hv_evmcs_vmptr' can also be EVMPTR_MAP_PENDING here */
    return vmx->nested.current_vmptr != -1ull ||
        nested_vmx_is_evmptr12_set(vmx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

vmx_leave_nested()

void vmx_leave_nested

(

struct kvm_vcpu *

vcpu

)

Definition at line 6568 of file nested.c.

{
    if (is_guest_mode(vcpu)) {
        to_vmx(vcpu)->nested.nested_run_pending = 0;
        nested_vmx_vmexit(vcpu, -1, 0, 0);
    }
    free_nested(vcpu);
}

Here is the call graph for this function:

Here is the caller graph for this function:

vmx_set_vmx_msr()

int vmx_set_vmx_msr	(	struct kvm_vcpu *	vcpu,
		u32	msr_index,
		u64	data
	)

Definition at line 1393 of file nested.c.

{
    struct vcpu_vmx *vmx = to_vmx(vcpu);
 
    /*
     * Don't allow changes to the VMX capability MSRs while the vCPU
     * is in VMX operation.
     */
    if (vmx->nested.vmxon)
        return -EBUSY;
 
    switch (msr_index) {
    case MSR_IA32_VMX_BASIC:
        return vmx_restore_vmx_basic(vmx, data);
    case MSR_IA32_VMX_PINBASED_CTLS:
    case MSR_IA32_VMX_PROCBASED_CTLS:
    case MSR_IA32_VMX_EXIT_CTLS:
    case MSR_IA32_VMX_ENTRY_CTLS:
        /*
         * The "non-true" VMX capability MSRs are generated from the
         * "true" MSRs, so we do not support restoring them directly.
         *
         * If userspace wants to emulate VMX_BASIC[55]=0, userspace
         * should restore the "true" MSRs with the must-be-1 bits
         * set according to the SDM Vol 3. A.2 "RESERVED CONTROLS AND
         * DEFAULT SETTINGS".
         */
        return -EINVAL;
    case MSR_IA32_VMX_TRUE_PINBASED_CTLS:
    case MSR_IA32_VMX_TRUE_PROCBASED_CTLS:
    case MSR_IA32_VMX_TRUE_EXIT_CTLS:
    case MSR_IA32_VMX_TRUE_ENTRY_CTLS:
    case MSR_IA32_VMX_PROCBASED_CTLS2:
        return vmx_restore_control_msr(vmx, msr_index, data);
    case MSR_IA32_VMX_MISC:
        return vmx_restore_vmx_misc(vmx, data);
    case MSR_IA32_VMX_CR0_FIXED0:
    case MSR_IA32_VMX_CR4_FIXED0:
        return vmx_restore_fixed0_msr(vmx, msr_index, data);
    case MSR_IA32_VMX_CR0_FIXED1:
    case MSR_IA32_VMX_CR4_FIXED1:
        /*
         * These MSRs are generated based on the vCPU's CPUID, so we
         * do not support restoring them directly.
         */
        return -EINVAL;
    case MSR_IA32_VMX_EPT_VPID_CAP:
        return vmx_restore_vmx_ept_vpid_cap(vmx, data);
    case MSR_IA32_VMX_VMCS_ENUM:
        vmx->nested.msrs.vmcs_enum = data;
        return 0;
    case MSR_IA32_VMX_VMFUNC:
        if (data & ~vmcs_config.nested.vmfunc_controls)
            return -EINVAL;
        vmx->nested.msrs.vmfunc_controls = data;
        return 0;
    default:
        /*
         * The rest of the VMX capability MSRs do not support restore.
         */
        return -EINVAL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

vmx_nested_ops

struct kvm_x86_nested_ops vmx_nested_ops

extern

Definition at line 7092 of file nested.c.