cpuid.h File Reference

#include "x86.h"
#include "reverse_cpuid.h"
#include <asm/cpu.h>
#include <asm/processor.h>
#include <uapi/asm/kvm_para.h>
#include "governed_features.h"

Include dependency graph for cpuid.h:

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

Go to the source code of this file.

Macros
#define	KVM_GOVERNED_FEATURE(x)   KVM_GOVERNED_##x,
#define	KVM_GOVERNED_FEATURE(x)   case x: return KVM_GOVERNED_##x;

Enumerations
enum	kvm_governed_features { KVM_NR_GOVERNED_FEATURES }

Functions
void	kvm_set_cpu_caps (void)
void	kvm_update_cpuid_runtime (struct kvm_vcpu *vcpu)
void	kvm_update_pv_runtime (struct kvm_vcpu *vcpu)
struct kvm_cpuid_entry2 *	kvm_find_cpuid_entry_index (struct kvm_vcpu *vcpu, u32 function, u32 index)
struct kvm_cpuid_entry2 *	kvm_find_cpuid_entry (struct kvm_vcpu *vcpu, u32 function)
int	kvm_dev_ioctl_get_cpuid (struct kvm_cpuid2 *cpuid, struct kvm_cpuid_entry2 __user *entries, unsigned int type)
int	kvm_vcpu_ioctl_set_cpuid (struct kvm_vcpu *vcpu, struct kvm_cpuid *cpuid, struct kvm_cpuid_entry __user *entries)
int	kvm_vcpu_ioctl_set_cpuid2 (struct kvm_vcpu *vcpu, struct kvm_cpuid2 *cpuid, struct kvm_cpuid_entry2 __user *entries)
int	kvm_vcpu_ioctl_get_cpuid2 (struct kvm_vcpu *vcpu, struct kvm_cpuid2 *cpuid, struct kvm_cpuid_entry2 __user *entries)
bool	kvm_cpuid (struct kvm_vcpu *vcpu, u32 *eax, u32 *ebx, u32 *ecx, u32 *edx, bool exact_only)
u32	xstate_required_size (u64 xstate_bv, bool compacted)
int	cpuid_query_maxphyaddr (struct kvm_vcpu *vcpu)
u64	kvm_vcpu_reserved_gpa_bits_raw (struct kvm_vcpu *vcpu)
static int	cpuid_maxphyaddr (struct kvm_vcpu *vcpu)
static bool	kvm_vcpu_is_legal_gpa (struct kvm_vcpu *vcpu, gpa_t gpa)
static bool	kvm_vcpu_is_legal_aligned_gpa (struct kvm_vcpu *vcpu, gpa_t gpa, gpa_t alignment)
static bool	page_address_valid (struct kvm_vcpu *vcpu, gpa_t gpa)
static __always_inline void	cpuid_entry_override (struct kvm_cpuid_entry2 *entry, unsigned int leaf)
static __always_inline u32 *	guest_cpuid_get_register (struct kvm_vcpu *vcpu, unsigned int x86_feature)
static __always_inline bool	guest_cpuid_has (struct kvm_vcpu *vcpu, unsigned int x86_feature)
static __always_inline void	guest_cpuid_clear (struct kvm_vcpu *vcpu, unsigned int x86_feature)
static bool	guest_cpuid_is_amd_or_hygon (struct kvm_vcpu *vcpu)
static bool	guest_cpuid_is_intel (struct kvm_vcpu *vcpu)
static bool	guest_cpuid_is_amd_compatible (struct kvm_vcpu *vcpu)
static bool	guest_cpuid_is_intel_compatible (struct kvm_vcpu *vcpu)
static int	guest_cpuid_family (struct kvm_vcpu *vcpu)
static int	guest_cpuid_model (struct kvm_vcpu *vcpu)
static bool	cpuid_model_is_consistent (struct kvm_vcpu *vcpu)
static int	guest_cpuid_stepping (struct kvm_vcpu *vcpu)
static bool	guest_has_spec_ctrl_msr (struct kvm_vcpu *vcpu)
static bool	guest_has_pred_cmd_msr (struct kvm_vcpu *vcpu)
static bool	supports_cpuid_fault (struct kvm_vcpu *vcpu)
static bool	cpuid_fault_enabled (struct kvm_vcpu *vcpu)
static __always_inline void	kvm_cpu_cap_clear (unsigned int x86_feature)
static __always_inline void	kvm_cpu_cap_set (unsigned int x86_feature)
static __always_inline u32	kvm_cpu_cap_get (unsigned int x86_feature)
static __always_inline bool	kvm_cpu_cap_has (unsigned int x86_feature)
static __always_inline void	kvm_cpu_cap_check_and_set (unsigned int x86_feature)
static __always_inline bool	guest_pv_has (struct kvm_vcpu *vcpu, unsigned int kvm_feature)
static __always_inline int	kvm_governed_feature_index (unsigned int x86_feature)
static __always_inline bool	kvm_is_governed_feature (unsigned int x86_feature)
static __always_inline void	kvm_governed_feature_set (struct kvm_vcpu *vcpu, unsigned int x86_feature)
static __always_inline void	kvm_governed_feature_check_and_set (struct kvm_vcpu *vcpu, unsigned int x86_feature)
static __always_inline bool	guest_can_use (struct kvm_vcpu *vcpu, unsigned int x86_feature)
static bool	kvm_vcpu_is_legal_cr3 (struct kvm_vcpu *vcpu, unsigned long cr3)

Variables
u32 kvm_cpu_caps[NR_KVM_CPU_CAPS]	__read_mostly

Macro Definition Documentation

KVM_GOVERNED_FEATURE [1/2]

#define KVM_GOVERNED_FEATURE

(

x

)

KVM_GOVERNED_##x,

Definition at line 242 of file cpuid.h.

KVM_GOVERNED_FEATURE [2/2]

#define KVM_GOVERNED_FEATURE

(

x

)

case x: return KVM_GOVERNED_##x;

Definition at line 242 of file cpuid.h.

Enumeration Type Documentation

kvm_governed_features

enum kvm_governed_features

Enumerator
KVM_NR_GOVERNED_FEATURES

Definition at line 241 of file cpuid.h.

                           {
#define KVM_GOVERNED_FEATURE(x) KVM_GOVERNED_##x,
#include "governed_features.h"
    KVM_NR_GOVERNED_FEATURES
};

Function Documentation

cpuid_entry_override()

static __always_inline void cpuid_entry_override ( struct kvm_cpuid_entry2 *  entry, unsigned int  leaf  )

static

Definition at line 61 of file cpuid.h.

{
    u32 *reg = cpuid_entry_get_reg(entry, leaf * 32);
 
    BUILD_BUG_ON(leaf >= ARRAY_SIZE(kvm_cpu_caps));
    *reg = kvm_cpu_caps[leaf];
}

Here is the call graph for this function:

Here is the caller graph for this function:

cpuid_fault_enabled()

static bool cpuid_fault_enabled ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 191 of file cpuid.h.

{
    return vcpu->arch.msr_misc_features_enables &
          MSR_MISC_FEATURES_ENABLES_CPUID_FAULT;
}

Here is the caller graph for this function:

cpuid_maxphyaddr()

static int cpuid_maxphyaddr ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 40 of file cpuid.h.

{
    return vcpu->arch.maxphyaddr;
}

Here is the caller graph for this function:

cpuid_model_is_consistent()

static bool cpuid_model_is_consistent ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 155 of file cpuid.h.

{
    return boot_cpu_data.x86_model == guest_cpuid_model(vcpu);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cpuid_query_maxphyaddr()

int cpuid_query_maxphyaddr

(

struct kvm_vcpu *

vcpu

)

Definition at line 390 of file cpuid.c.

{
    struct kvm_cpuid_entry2 *best;
 
    best = kvm_find_cpuid_entry(vcpu, 0x80000000);
    if (!best || best->eax < 0x80000008)
        goto not_found;
    best = kvm_find_cpuid_entry(vcpu, 0x80000008);
    if (best)
        return best->eax & 0xff;
not_found:
    return 36;
}

Here is the call graph for this function:

Here is the caller graph for this function:

guest_can_use()

static __always_inline bool guest_can_use ( struct kvm_vcpu *  vcpu, unsigned int  x86_feature  )

static

Definition at line 278 of file cpuid.h.

{
    BUILD_BUG_ON(!kvm_is_governed_feature(x86_feature));
 
    return test_bit(kvm_governed_feature_index(x86_feature),
            vcpu->arch.governed_features.enabled);
}

Here is the call graph for this function:

Here is the caller graph for this function:

guest_cpuid_clear()

static __always_inline void guest_cpuid_clear ( struct kvm_vcpu *  vcpu, unsigned int  x86_feature  )

static

Definition at line 95 of file cpuid.h.

{
    u32 *reg;
 
    reg = guest_cpuid_get_register(vcpu, x86_feature);
    if (reg)
        *reg &= ~__feature_bit(x86_feature);
}

Here is the call graph for this function:

guest_cpuid_family()

static int guest_cpuid_family ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 133 of file cpuid.h.

{
    struct kvm_cpuid_entry2 *best;
 
    best = kvm_find_cpuid_entry(vcpu, 0x1);
    if (!best)
        return -1;
 
    return x86_family(best->eax);
}

Here is the call graph for this function:

Here is the caller graph for this function:

guest_cpuid_get_register()

static __always_inline u32* guest_cpuid_get_register ( struct kvm_vcpu *  vcpu, unsigned int  x86_feature  )

static

Definition at line 70 of file cpuid.h.

{
    const struct cpuid_reg cpuid = x86_feature_cpuid(x86_feature);
    struct kvm_cpuid_entry2 *entry;
 
    entry = kvm_find_cpuid_entry_index(vcpu, cpuid.function, cpuid.index);
    if (!entry)
        return NULL;
 
    return __cpuid_entry_get_reg(entry, cpuid.reg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

guest_cpuid_has()

static __always_inline bool guest_cpuid_has ( struct kvm_vcpu *  vcpu, unsigned int  x86_feature  )

static

Definition at line 83 of file cpuid.h.

{
    u32 *reg;
 
    reg = guest_cpuid_get_register(vcpu, x86_feature);
    if (!reg)
        return false;
 
    return *reg & __feature_bit(x86_feature);
}

Here is the call graph for this function:

Here is the caller graph for this function:

guest_cpuid_is_amd_compatible()

static bool guest_cpuid_is_amd_compatible ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 123 of file cpuid.h.

{
    return vcpu->arch.is_amd_compatible;
}

Here is the caller graph for this function:

guest_cpuid_is_amd_or_hygon()

static bool guest_cpuid_is_amd_or_hygon ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 105 of file cpuid.h.

{
    struct kvm_cpuid_entry2 *best;
 
    best = kvm_find_cpuid_entry(vcpu, 0);
    return best &&
           (is_guest_vendor_amd(best->ebx, best->ecx, best->edx) ||
        is_guest_vendor_hygon(best->ebx, best->ecx, best->edx));
}

Here is the call graph for this function:

Here is the caller graph for this function:

guest_cpuid_is_intel()

static bool guest_cpuid_is_intel ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 115 of file cpuid.h.

{
    struct kvm_cpuid_entry2 *best;
 
    best = kvm_find_cpuid_entry(vcpu, 0);
    return best && is_guest_vendor_intel(best->ebx, best->ecx, best->edx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

guest_cpuid_is_intel_compatible()

static bool guest_cpuid_is_intel_compatible ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 128 of file cpuid.h.

{
    return !guest_cpuid_is_amd_compatible(vcpu);
}

Here is the call graph for this function:

Here is the caller graph for this function:

guest_cpuid_model()

static int guest_cpuid_model ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 144 of file cpuid.h.

{
    struct kvm_cpuid_entry2 *best;
 
    best = kvm_find_cpuid_entry(vcpu, 0x1);
    if (!best)
        return -1;
 
    return x86_model(best->eax);
}

Here is the call graph for this function:

Here is the caller graph for this function:

guest_cpuid_stepping()

static int guest_cpuid_stepping ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 160 of file cpuid.h.

{
    struct kvm_cpuid_entry2 *best;
 
    best = kvm_find_cpuid_entry(vcpu, 0x1);
    if (!best)
        return -1;
 
    return x86_stepping(best->eax);
}

Here is the call graph for this function:

guest_has_pred_cmd_msr()

static bool guest_has_pred_cmd_msr ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 179 of file cpuid.h.

{
    return (guest_cpuid_has(vcpu, X86_FEATURE_SPEC_CTRL) ||
        guest_cpuid_has(vcpu, X86_FEATURE_AMD_IBPB) ||
        guest_cpuid_has(vcpu, X86_FEATURE_SBPB));
}

Here is the call graph for this function:

Here is the caller graph for this function:

guest_has_spec_ctrl_msr()

static bool guest_has_spec_ctrl_msr ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 171 of file cpuid.h.

{
    return (guest_cpuid_has(vcpu, X86_FEATURE_SPEC_CTRL) ||
        guest_cpuid_has(vcpu, X86_FEATURE_AMD_STIBP) ||
        guest_cpuid_has(vcpu, X86_FEATURE_AMD_IBRS) ||
        guest_cpuid_has(vcpu, X86_FEATURE_AMD_SSBD));
}

Here is the call graph for this function:

Here is the caller graph for this function:

guest_pv_has()

static __always_inline bool guest_pv_has ( struct kvm_vcpu *  vcpu, unsigned int  kvm_feature  )

static

Definition at line 232 of file cpuid.h.

{
    if (!vcpu->arch.pv_cpuid.enforce)
        return true;
 
    return vcpu->arch.pv_cpuid.features & (1u << kvm_feature);
}

Here is the caller graph for this function:

kvm_cpu_cap_check_and_set()

static __always_inline void kvm_cpu_cap_check_and_set ( unsigned int  x86_feature )

static

Definition at line 226 of file cpuid.h.

{
    if (boot_cpu_has(x86_feature))
        kvm_cpu_cap_set(x86_feature);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_cpu_cap_clear()

static __always_inline void kvm_cpu_cap_clear ( unsigned int  x86_feature )

static

Definition at line 197 of file cpuid.h.

{
    unsigned int x86_leaf = __feature_leaf(x86_feature);
 
    reverse_cpuid_check(x86_leaf);
    kvm_cpu_caps[x86_leaf] &= ~__feature_bit(x86_feature);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_cpu_cap_get()

static __always_inline u32 kvm_cpu_cap_get ( unsigned int  x86_feature )

static

Definition at line 213 of file cpuid.h.

{
    unsigned int x86_leaf = __feature_leaf(x86_feature);
 
    reverse_cpuid_check(x86_leaf);
    return kvm_cpu_caps[x86_leaf] & __feature_bit(x86_feature);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_cpu_cap_has()

static __always_inline bool kvm_cpu_cap_has ( unsigned int  x86_feature )

static

Definition at line 221 of file cpuid.h.

{
    return !!kvm_cpu_cap_get(x86_feature);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_cpu_cap_set()

static __always_inline void kvm_cpu_cap_set ( unsigned int  x86_feature )

static

Definition at line 205 of file cpuid.h.

{
    unsigned int x86_leaf = __feature_leaf(x86_feature);
 
    reverse_cpuid_check(x86_leaf);
    kvm_cpu_caps[x86_leaf] |= __feature_bit(x86_feature);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_cpuid()

bool kvm_cpuid	(	struct kvm_vcpu *	vcpu,
		u32 *	eax,
		u32 *	ebx,
		u32 *	ecx,
		u32 *	edx,
		bool	exact_only
	)

Definition at line 1531 of file cpuid.c.

{
    u32 orig_function = *eax, function = *eax, index = *ecx;
    struct kvm_cpuid_entry2 *entry;
    bool exact, used_max_basic = false;
 
    entry = kvm_find_cpuid_entry_index(vcpu, function, index);
    exact = !!entry;
 
    if (!entry && !exact_only) {
        entry = get_out_of_range_cpuid_entry(vcpu, &function, index);
        used_max_basic = !!entry;
    }
 
    if (entry) {
        *eax = entry->eax;
        *ebx = entry->ebx;
        *ecx = entry->ecx;
        *edx = entry->edx;
        if (function == 7 && index == 0) {
            u64 data;
                if (!__kvm_get_msr(vcpu, MSR_IA32_TSX_CTRL, &data, true) &&
                (data & TSX_CTRL_CPUID_CLEAR))
                *ebx &= ~(F(RTM) | F(HLE));
        } else if (function == 0x80000007) {
            if (kvm_hv_invtsc_suppressed(vcpu))
                *edx &= ~SF(CONSTANT_TSC);
        }
    } else {
        *eax = *ebx = *ecx = *edx = 0;
        /*
         * When leaf 0BH or 1FH is defined, CL is pass-through
         * and EDX is always the x2APIC ID, even for undefined
         * subleaves. Index 1 will exist iff the leaf is
         * implemented, so we pass through CL iff leaf 1
         * exists. EDX can be copied from any existing index.
         */
        if (function == 0xb || function == 0x1f) {
            entry = kvm_find_cpuid_entry_index(vcpu, function, 1);
            if (entry) {
                *ecx = index & 0xff;
                *edx = entry->edx;
            }
        }
    }
    trace_kvm_cpuid(orig_function, index, *eax, *ebx, *ecx, *edx, exact,
            used_max_basic);
    return exact;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_dev_ioctl_get_cpuid()

int kvm_dev_ioctl_get_cpuid	(	struct kvm_cpuid2 *	cpuid,
		struct kvm_cpuid_entry2 __user *	entries,
		unsigned int	type
	)

Definition at line 1404 of file cpuid.c.

{
    static const u32 funcs[] = {
        0, 0x80000000, CENTAUR_CPUID_SIGNATURE, KVM_CPUID_SIGNATURE,
    };
 
    struct kvm_cpuid_array array = {
        .nent = 0,
    };
    int r, i;
 
    if (cpuid->nent < 1)
        return -E2BIG;
    if (cpuid->nent > KVM_MAX_CPUID_ENTRIES)
        cpuid->nent = KVM_MAX_CPUID_ENTRIES;
 
    if (sanity_check_entries(entries, cpuid->nent, type))
        return -EINVAL;
 
    array.entries = kvcalloc(cpuid->nent, sizeof(struct kvm_cpuid_entry2), GFP_KERNEL);
    if (!array.entries)
        return -ENOMEM;
 
    array.maxnent = cpuid->nent;
 
    for (i = 0; i < ARRAY_SIZE(funcs); i++) {
        r = get_cpuid_func(&array, funcs[i], type);
        if (r)
            goto out_free;
    }
    cpuid->nent = array.nent;
 
    if (copy_to_user(entries, array.entries,
             array.nent * sizeof(struct kvm_cpuid_entry2)))
        r = -EFAULT;
 
out_free:
    kvfree(array.entries);
    return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_find_cpuid_entry()

struct kvm_cpuid_entry2* kvm_find_cpuid_entry	(	struct kvm_vcpu *	vcpu,
		u32	function
	)

Definition at line 1455 of file cpuid.c.

{
    return cpuid_entry2_find(vcpu->arch.cpuid_entries, vcpu->arch.cpuid_nent,
                 function, KVM_CPUID_INDEX_NOT_SIGNIFICANT);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_find_cpuid_entry_index()

struct kvm_cpuid_entry2* kvm_find_cpuid_entry_index	(	struct kvm_vcpu *	vcpu,
		u32	function,
		u32	index
	)

Definition at line 1447 of file cpuid.c.

{
    return cpuid_entry2_find(vcpu->arch.cpuid_entries, vcpu->arch.cpuid_nent,
                 function, index);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_governed_feature_check_and_set()

static __always_inline void kvm_governed_feature_check_and_set ( struct kvm_vcpu *  vcpu, unsigned int  x86_feature  )

static

Definition at line 271 of file cpuid.h.

{
    if (kvm_cpu_cap_has(x86_feature) && guest_cpuid_has(vcpu, x86_feature))
        kvm_governed_feature_set(vcpu, x86_feature);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_governed_feature_index()

static __always_inline int kvm_governed_feature_index ( unsigned int  x86_feature )

static

Definition at line 247 of file cpuid.h.

{
    switch (x86_feature) {
#define KVM_GOVERNED_FEATURE(x) case x: return KVM_GOVERNED_##x;
#include "governed_features.h"
    default:
        return -1;
    }
}

Here is the caller graph for this function:

kvm_governed_feature_set()

static __always_inline void kvm_governed_feature_set ( struct kvm_vcpu *  vcpu, unsigned int  x86_feature  )

static

Definition at line 262 of file cpuid.h.

{
    BUILD_BUG_ON(!kvm_is_governed_feature(x86_feature));
 
    __set_bit(kvm_governed_feature_index(x86_feature),
          vcpu->arch.governed_features.enabled);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_is_governed_feature()

static __always_inline bool kvm_is_governed_feature ( unsigned int  x86_feature )

static

Definition at line 257 of file cpuid.h.

{
    return kvm_governed_feature_index(x86_feature) >= 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_set_cpu_caps()

void kvm_set_cpu_caps

(

void

)

Definition at line 585 of file cpuid.c.

{
#ifdef CONFIG_X86_64
    unsigned int f_gbpages = F(GBPAGES);
    unsigned int f_lm = F(LM);
    unsigned int f_xfd = F(XFD);
#else
    unsigned int f_gbpages = 0;
    unsigned int f_lm = 0;
    unsigned int f_xfd = 0;
#endif
    memset(kvm_cpu_caps, 0, sizeof(kvm_cpu_caps));
 
    BUILD_BUG_ON(sizeof(kvm_cpu_caps) - (NKVMCAPINTS * sizeof(*kvm_cpu_caps)) >
             sizeof(boot_cpu_data.x86_capability));
 
    memcpy(&kvm_cpu_caps, &boot_cpu_data.x86_capability,
           sizeof(kvm_cpu_caps) - (NKVMCAPINTS * sizeof(*kvm_cpu_caps)));
 
    kvm_cpu_cap_mask(CPUID_1_ECX,
        /*
         * NOTE: MONITOR (and MWAIT) are emulated as NOP, but *not*
         * advertised to guests via CPUID!
         */
        F(XMM3) | F(PCLMULQDQ) | 0 /* DTES64, MONITOR */ |
        0 /* DS-CPL, VMX, SMX, EST */ |
        0 /* TM2 */ | F(SSSE3) | 0 /* CNXT-ID */ | 0 /* Reserved */ |
        F(FMA) | F(CX16) | 0 /* xTPR Update */ | F(PDCM) |
        F(PCID) | 0 /* Reserved, DCA */ | F(XMM4_1) |
        F(XMM4_2) | F(X2APIC) | F(MOVBE) | F(POPCNT) |
        0 /* Reserved*/ | F(AES) | F(XSAVE) | 0 /* OSXSAVE */ | F(AVX) |
        F(F16C) | F(RDRAND)
    );
    /* KVM emulates x2apic in software irrespective of host support. */
    kvm_cpu_cap_set(X86_FEATURE_X2APIC);
 
    kvm_cpu_cap_mask(CPUID_1_EDX,
        F(FPU) | F(VME) | F(DE) | F(PSE) |
        F(TSC) | F(MSR) | F(PAE) | F(MCE) |
        F(CX8) | F(APIC) | 0 /* Reserved */ | F(SEP) |
        F(MTRR) | F(PGE) | F(MCA) | F(CMOV) |
        F(PAT) | F(PSE36) | 0 /* PSN */ | F(CLFLUSH) |
        0 /* Reserved, DS, ACPI */ | F(MMX) |
        F(FXSR) | F(XMM) | F(XMM2) | F(SELFSNOOP) |
        0 /* HTT, TM, Reserved, PBE */
    );
 
    kvm_cpu_cap_mask(CPUID_7_0_EBX,
        F(FSGSBASE) | F(SGX) | F(BMI1) | F(HLE) | F(AVX2) |
        F(FDP_EXCPTN_ONLY) | F(SMEP) | F(BMI2) | F(ERMS) | F(INVPCID) |
        F(RTM) | F(ZERO_FCS_FDS) | 0 /*MPX*/ | F(AVX512F) |
        F(AVX512DQ) | F(RDSEED) | F(ADX) | F(SMAP) | F(AVX512IFMA) |
        F(CLFLUSHOPT) | F(CLWB) | 0 /*INTEL_PT*/ | F(AVX512PF) |
        F(AVX512ER) | F(AVX512CD) | F(SHA_NI) | F(AVX512BW) |
        F(AVX512VL));
 
    kvm_cpu_cap_mask(CPUID_7_ECX,
        F(AVX512VBMI) | F(LA57) | F(PKU) | 0 /*OSPKE*/ | F(RDPID) |
        F(AVX512_VPOPCNTDQ) | F(UMIP) | F(AVX512_VBMI2) | F(GFNI) |
        F(VAES) | F(VPCLMULQDQ) | F(AVX512_VNNI) | F(AVX512_BITALG) |
        F(CLDEMOTE) | F(MOVDIRI) | F(MOVDIR64B) | 0 /*WAITPKG*/ |
        F(SGX_LC) | F(BUS_LOCK_DETECT)
    );
    /* Set LA57 based on hardware capability. */
    if (cpuid_ecx(7) & F(LA57))
        kvm_cpu_cap_set(X86_FEATURE_LA57);
 
    /*
     * PKU not yet implemented for shadow paging and requires OSPKE
     * to be set on the host. Clear it if that is not the case
     */
    if (!tdp_enabled || !boot_cpu_has(X86_FEATURE_OSPKE))
        kvm_cpu_cap_clear(X86_FEATURE_PKU);
 
    kvm_cpu_cap_mask(CPUID_7_EDX,
        F(AVX512_4VNNIW) | F(AVX512_4FMAPS) | F(SPEC_CTRL) |
        F(SPEC_CTRL_SSBD) | F(ARCH_CAPABILITIES) | F(INTEL_STIBP) |
        F(MD_CLEAR) | F(AVX512_VP2INTERSECT) | F(FSRM) |
        F(SERIALIZE) | F(TSXLDTRK) | F(AVX512_FP16) |
        F(AMX_TILE) | F(AMX_INT8) | F(AMX_BF16) | F(FLUSH_L1D)
    );
 
    /* TSC_ADJUST and ARCH_CAPABILITIES are emulated in software. */
    kvm_cpu_cap_set(X86_FEATURE_TSC_ADJUST);
    kvm_cpu_cap_set(X86_FEATURE_ARCH_CAPABILITIES);
 
    if (boot_cpu_has(X86_FEATURE_IBPB) && boot_cpu_has(X86_FEATURE_IBRS))
        kvm_cpu_cap_set(X86_FEATURE_SPEC_CTRL);
    if (boot_cpu_has(X86_FEATURE_STIBP))
        kvm_cpu_cap_set(X86_FEATURE_INTEL_STIBP);
    if (boot_cpu_has(X86_FEATURE_AMD_SSBD))
        kvm_cpu_cap_set(X86_FEATURE_SPEC_CTRL_SSBD);
 
    kvm_cpu_cap_mask(CPUID_7_1_EAX,
        F(AVX_VNNI) | F(AVX512_BF16) | F(CMPCCXADD) |
        F(FZRM) | F(FSRS) | F(FSRC) |
        F(AMX_FP16) | F(AVX_IFMA) | F(LAM)
    );
 
    kvm_cpu_cap_init_kvm_defined(CPUID_7_1_EDX,
        F(AVX_VNNI_INT8) | F(AVX_NE_CONVERT) | F(PREFETCHITI) |
        F(AMX_COMPLEX)
    );
 
    kvm_cpu_cap_init_kvm_defined(CPUID_7_2_EDX,
        F(INTEL_PSFD) | F(IPRED_CTRL) | F(RRSBA_CTRL) | F(DDPD_U) |
        F(BHI_CTRL) | F(MCDT_NO)
    );
 
    kvm_cpu_cap_mask(CPUID_D_1_EAX,
        F(XSAVEOPT) | F(XSAVEC) | F(XGETBV1) | F(XSAVES) | f_xfd
    );
 
    kvm_cpu_cap_init_kvm_defined(CPUID_12_EAX,
        SF(SGX1) | SF(SGX2) | SF(SGX_EDECCSSA)
    );
 
    kvm_cpu_cap_mask(CPUID_8000_0001_ECX,
        F(LAHF_LM) | F(CMP_LEGACY) | 0 /*SVM*/ | 0 /* ExtApicSpace */ |
        F(CR8_LEGACY) | F(ABM) | F(SSE4A) | F(MISALIGNSSE) |
        F(3DNOWPREFETCH) | F(OSVW) | 0 /* IBS */ | F(XOP) |
        0 /* SKINIT, WDT, LWP */ | F(FMA4) | F(TBM) |
        F(TOPOEXT) | 0 /* PERFCTR_CORE */
    );
 
    kvm_cpu_cap_mask(CPUID_8000_0001_EDX,
        F(FPU) | F(VME) | F(DE) | F(PSE) |
        F(TSC) | F(MSR) | F(PAE) | F(MCE) |
        F(CX8) | F(APIC) | 0 /* Reserved */ | F(SYSCALL) |
        F(MTRR) | F(PGE) | F(MCA) | F(CMOV) |
        F(PAT) | F(PSE36) | 0 /* Reserved */ |
        F(NX) | 0 /* Reserved */ | F(MMXEXT) | F(MMX) |
        F(FXSR) | F(FXSR_OPT) | f_gbpages | F(RDTSCP) |
        0 /* Reserved */ | f_lm | F(3DNOWEXT) | F(3DNOW)
    );
 
    if (!tdp_enabled && IS_ENABLED(CONFIG_X86_64))
        kvm_cpu_cap_set(X86_FEATURE_GBPAGES);
 
    kvm_cpu_cap_init_kvm_defined(CPUID_8000_0007_EDX,
        SF(CONSTANT_TSC)
    );
 
    kvm_cpu_cap_mask(CPUID_8000_0008_EBX,
        F(CLZERO) | F(XSAVEERPTR) |
        F(WBNOINVD) | F(AMD_IBPB) | F(AMD_IBRS) | F(AMD_SSBD) | F(VIRT_SSBD) |
        F(AMD_SSB_NO) | F(AMD_STIBP) | F(AMD_STIBP_ALWAYS_ON) |
        F(AMD_PSFD)
    );
 
    /*
     * AMD has separate bits for each SPEC_CTRL bit.
     * arch/x86/kernel/cpu/bugs.c is kind enough to
     * record that in cpufeatures so use them.
     */
    if (boot_cpu_has(X86_FEATURE_IBPB))
        kvm_cpu_cap_set(X86_FEATURE_AMD_IBPB);
    if (boot_cpu_has(X86_FEATURE_IBRS))
        kvm_cpu_cap_set(X86_FEATURE_AMD_IBRS);
    if (boot_cpu_has(X86_FEATURE_STIBP))
        kvm_cpu_cap_set(X86_FEATURE_AMD_STIBP);
    if (boot_cpu_has(X86_FEATURE_SPEC_CTRL_SSBD))
        kvm_cpu_cap_set(X86_FEATURE_AMD_SSBD);
    if (!boot_cpu_has_bug(X86_BUG_SPEC_STORE_BYPASS))
        kvm_cpu_cap_set(X86_FEATURE_AMD_SSB_NO);
    /*
     * The preference is to use SPEC CTRL MSR instead of the
     * VIRT_SPEC MSR.
     */
    if (boot_cpu_has(X86_FEATURE_LS_CFG_SSBD) &&
        !boot_cpu_has(X86_FEATURE_AMD_SSBD))
        kvm_cpu_cap_set(X86_FEATURE_VIRT_SSBD);
 
    /*
     * Hide all SVM features by default, SVM will set the cap bits for
     * features it emulates and/or exposes for L1.
     */
    kvm_cpu_cap_mask(CPUID_8000_000A_EDX, 0);
 
    kvm_cpu_cap_mask(CPUID_8000_001F_EAX,
        0 /* SME */ | F(SEV) | 0 /* VM_PAGE_FLUSH */ | F(SEV_ES) |
        F(SME_COHERENT));
 
    kvm_cpu_cap_mask(CPUID_8000_0021_EAX,
        F(NO_NESTED_DATA_BP) | F(LFENCE_RDTSC) | 0 /* SmmPgCfgLock */ |
        F(NULL_SEL_CLR_BASE) | F(AUTOIBRS) | 0 /* PrefetchCtlMsr */ |
        F(WRMSR_XX_BASE_NS)
    );
 
    kvm_cpu_cap_check_and_set(X86_FEATURE_SBPB);
    kvm_cpu_cap_check_and_set(X86_FEATURE_IBPB_BRTYPE);
    kvm_cpu_cap_check_and_set(X86_FEATURE_SRSO_NO);
 
    kvm_cpu_cap_init_kvm_defined(CPUID_8000_0022_EAX,
        F(PERFMON_V2)
    );
 
    /*
     * Synthesize "LFENCE is serializing" into the AMD-defined entry in
     * KVM's supported CPUID if the feature is reported as supported by the
     * kernel.  LFENCE_RDTSC was a Linux-defined synthetic feature long
     * before AMD joined the bandwagon, e.g. LFENCE is serializing on most
     * CPUs that support SSE2.  On CPUs that don't support AMD's leaf,
     * kvm_cpu_cap_mask() will unfortunately drop the flag due to ANDing
     * the mask with the raw host CPUID, and reporting support in AMD's
     * leaf can make it easier for userspace to detect the feature.
     */
    if (cpu_feature_enabled(X86_FEATURE_LFENCE_RDTSC))
        kvm_cpu_cap_set(X86_FEATURE_LFENCE_RDTSC);
    if (!static_cpu_has_bug(X86_BUG_NULL_SEG))
        kvm_cpu_cap_set(X86_FEATURE_NULL_SEL_CLR_BASE);
    kvm_cpu_cap_set(X86_FEATURE_NO_SMM_CTL_MSR);
 
    kvm_cpu_cap_mask(CPUID_C000_0001_EDX,
        F(XSTORE) | F(XSTORE_EN) | F(XCRYPT) | F(XCRYPT_EN) |
        F(ACE2) | F(ACE2_EN) | F(PHE) | F(PHE_EN) |
        F(PMM) | F(PMM_EN)
    );
 
    /*
     * Hide RDTSCP and RDPID if either feature is reported as supported but
     * probing MSR_TSC_AUX failed.  This is purely a sanity check and
     * should never happen, but the guest will likely crash if RDTSCP or
     * RDPID is misreported, and KVM has botched MSR_TSC_AUX emulation in
     * the past.  For example, the sanity check may fire if this instance of
     * KVM is running as L1 on top of an older, broken KVM.
     */
    if (WARN_ON((kvm_cpu_cap_has(X86_FEATURE_RDTSCP) ||
             kvm_cpu_cap_has(X86_FEATURE_RDPID)) &&
             !kvm_is_supported_user_return_msr(MSR_TSC_AUX))) {
        kvm_cpu_cap_clear(X86_FEATURE_RDTSCP);
        kvm_cpu_cap_clear(X86_FEATURE_RDPID);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_update_cpuid_runtime()

void kvm_update_cpuid_runtime

(

struct kvm_vcpu *

vcpu

)

Definition at line 309 of file cpuid.c.

{
    __kvm_update_cpuid_runtime(vcpu, vcpu->arch.cpuid_entries, vcpu->arch.cpuid_nent);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_update_pv_runtime()

void kvm_update_pv_runtime

(

struct kvm_vcpu *

vcpu

)

Definition at line 238 of file cpuid.c.

{
    struct kvm_cpuid_entry2 *best = kvm_find_kvm_cpuid_features(vcpu);
 
    /*
     * save the feature bitmap to avoid cpuid lookup for every PV
     * operation
     */
    if (best)
        vcpu->arch.pv_cpuid.features = best->eax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_vcpu_ioctl_get_cpuid2()

int kvm_vcpu_ioctl_get_cpuid2	(	struct kvm_vcpu *	vcpu,
		struct kvm_cpuid2 *	cpuid,
		struct kvm_cpuid_entry2 __user *	entries
	)

Definition at line 535 of file cpuid.c.

{
    if (cpuid->nent < vcpu->arch.cpuid_nent)
        return -E2BIG;
 
    if (copy_to_user(entries, vcpu->arch.cpuid_entries,
             vcpu->arch.cpuid_nent * sizeof(struct kvm_cpuid_entry2)))
        return -EFAULT;
 
    cpuid->nent = vcpu->arch.cpuid_nent;
    return 0;
}

Here is the caller graph for this function:

kvm_vcpu_ioctl_set_cpuid()

int kvm_vcpu_ioctl_set_cpuid	(	struct kvm_vcpu *	vcpu,
		struct kvm_cpuid *	cpuid,
		struct kvm_cpuid_entry __user *	entries
	)

Definition at line 467 of file cpuid.c.

{
    int r, i;
    struct kvm_cpuid_entry *e = NULL;
    struct kvm_cpuid_entry2 *e2 = NULL;
 
    if (cpuid->nent > KVM_MAX_CPUID_ENTRIES)
        return -E2BIG;
 
    if (cpuid->nent) {
        e = vmemdup_array_user(entries, cpuid->nent, sizeof(*e));
        if (IS_ERR(e))
            return PTR_ERR(e);
 
        e2 = kvmalloc_array(cpuid->nent, sizeof(*e2), GFP_KERNEL_ACCOUNT);
        if (!e2) {
            r = -ENOMEM;
            goto out_free_cpuid;
        }
    }
    for (i = 0; i < cpuid->nent; i++) {
        e2[i].function = e[i].function;
        e2[i].eax = e[i].eax;
        e2[i].ebx = e[i].ebx;
        e2[i].ecx = e[i].ecx;
        e2[i].edx = e[i].edx;
        e2[i].index = 0;
        e2[i].flags = 0;
        e2[i].padding[0] = 0;
        e2[i].padding[1] = 0;
        e2[i].padding[2] = 0;
    }
 
    r = kvm_set_cpuid(vcpu, e2, cpuid->nent);
    if (r)
        kvfree(e2);
 
out_free_cpuid:
    kvfree(e);
 
    return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_vcpu_ioctl_set_cpuid2()

int kvm_vcpu_ioctl_set_cpuid2	(	struct kvm_vcpu *	vcpu,
		struct kvm_cpuid2 *	cpuid,
		struct kvm_cpuid_entry2 __user *	entries
	)

Definition at line 512 of file cpuid.c.

{
    struct kvm_cpuid_entry2 *e2 = NULL;
    int r;
 
    if (cpuid->nent > KVM_MAX_CPUID_ENTRIES)
        return -E2BIG;
 
    if (cpuid->nent) {
        e2 = vmemdup_array_user(entries, cpuid->nent, sizeof(*e2));
        if (IS_ERR(e2))
            return PTR_ERR(e2);
    }
 
    r = kvm_set_cpuid(vcpu, e2, cpuid->nent);
    if (r)
        kvfree(e2);
 
    return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_vcpu_is_legal_aligned_gpa()

static bool kvm_vcpu_is_legal_aligned_gpa ( struct kvm_vcpu *  vcpu, gpa_t  gpa, gpa_t  alignment  )

inlinestatic

Definition at line 50 of file cpuid.h.

{
    return IS_ALIGNED(gpa, alignment) && kvm_vcpu_is_legal_gpa(vcpu, gpa);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_vcpu_is_legal_cr3()

static bool kvm_vcpu_is_legal_cr3 ( struct kvm_vcpu *  vcpu, unsigned long  cr3  )

inlinestatic

Definition at line 287 of file cpuid.h.

{
    if (guest_can_use(vcpu, X86_FEATURE_LAM))
        cr3 &= ~(X86_CR3_LAM_U48 | X86_CR3_LAM_U57);
 
    return kvm_vcpu_is_legal_gpa(vcpu, cr3);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_vcpu_is_legal_gpa()

static bool kvm_vcpu_is_legal_gpa ( struct kvm_vcpu *  vcpu, gpa_t  gpa  )

inlinestatic

Definition at line 45 of file cpuid.h.

{
    return !(gpa & vcpu->arch.reserved_gpa_bits);
}

Here is the caller graph for this function:

kvm_vcpu_reserved_gpa_bits_raw()

u64 kvm_vcpu_reserved_gpa_bits_raw

(

struct kvm_vcpu *

vcpu

)

Definition at line 409 of file cpuid.c.

{
    return rsvd_bits(cpuid_maxphyaddr(vcpu), 63);
}

Here is the call graph for this function:

Here is the caller graph for this function:

page_address_valid()

static bool page_address_valid ( struct kvm_vcpu *  vcpu, gpa_t  gpa  )

inlinestatic

Definition at line 56 of file cpuid.h.

{
    return kvm_vcpu_is_legal_aligned_gpa(vcpu, gpa, PAGE_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

supports_cpuid_fault()

static bool supports_cpuid_fault ( struct kvm_vcpu *  vcpu )

inlinestatic

Definition at line 186 of file cpuid.h.

{
    return vcpu->arch.msr_platform_info & MSR_PLATFORM_INFO_CPUID_FAULT;
}

Here is the caller graph for this function:

xstate_required_size()

u32 xstate_required_size	(	u64	xstate_bv,
		bool	compacted
	)

Definition at line 39 of file cpuid.c.

{
    int feature_bit = 0;
    u32 ret = XSAVE_HDR_SIZE + XSAVE_HDR_OFFSET;
 
    xstate_bv &= XFEATURE_MASK_EXTEND;
    while (xstate_bv) {
        if (xstate_bv & 0x1) {
                u32 eax, ebx, ecx, edx, offset;
                cpuid_count(0xD, feature_bit, &eax, &ebx, &ecx, &edx);
            /* ECX[1]: 64B alignment in compacted form */
            if (compacted)
                offset = (ecx & 0x2) ? ALIGN(ret, 64) : ret;
            else
                offset = ebx;
            ret = max(ret, offset + eax);
        }
 
        xstate_bv >>= 1;
        feature_bit++;
    }
 
    return ret;
}

Here is the caller graph for this function:

Variable Documentation

__read_mostly

u32 kvm_cpu_caps [NR_KVM_CPU_CAPS] __read_mostly

extern

Definition at line 36 of file cpuid.c.