mtrr.c File Reference

#include <linux/kvm_host.h>
#include <asm/mtrr.h>
#include "cpuid.h"
#include "mmu.h"

Include dependency graph for mtrr.c:

Go to the source code of this file.

Classes
struct	fixed_mtrr_segment
struct	mtrr_iter

Macros
#define	pr_fmt(fmt)   KBUILD_MODNAME ": " fmt
#define	IA32_MTRR_DEF_TYPE_E   (1ULL << 11)
#define	IA32_MTRR_DEF_TYPE_FE   (1ULL << 10)
#define	IA32_MTRR_DEF_TYPE_TYPE_MASK   (0xff)
#define	mtrr_for_each_mem_type(_iter_, _mtrr_, _gpa_start_, _gpa_end_)

Functions
static bool	is_mtrr_base_msr (unsigned int msr)
static struct kvm_mtrr_range *	var_mtrr_msr_to_range (struct kvm_vcpu *vcpu, unsigned int msr)
static bool	msr_mtrr_valid (unsigned msr)
static bool	valid_mtrr_type (unsigned t)
static bool	kvm_mtrr_valid (struct kvm_vcpu *vcpu, u32 msr, u64 data)
static bool	mtrr_is_enabled (struct kvm_mtrr *mtrr_state)
static bool	fixed_mtrr_is_enabled (struct kvm_mtrr *mtrr_state)
static u8	mtrr_default_type (struct kvm_mtrr *mtrr_state)
static u8	mtrr_disabled_type (struct kvm_vcpu *vcpu)
static u64	fixed_mtrr_seg_unit_size (int seg)
static bool	fixed_msr_to_seg_unit (u32 msr, int *seg, int *unit)
static void	fixed_mtrr_seg_unit_range (int seg, int unit, u64 *start, u64 *end)
static int	fixed_mtrr_seg_unit_range_index (int seg, int unit)
static int	fixed_mtrr_seg_end_range_index (int seg)
static bool	fixed_msr_to_range (u32 msr, u64 *start, u64 *end)
static int	fixed_msr_to_range_index (u32 msr)
static int	fixed_mtrr_addr_to_seg (u64 addr)
static int	fixed_mtrr_addr_seg_to_range_index (u64 addr, int seg)
static u64	fixed_mtrr_range_end_addr (int seg, int index)
static void	var_mtrr_range (struct kvm_mtrr_range *range, u64 *start, u64 *end)
static void	update_mtrr (struct kvm_vcpu *vcpu, u32 msr)
static bool	var_mtrr_range_is_valid (struct kvm_mtrr_range *range)
static void	set_var_mtrr_msr (struct kvm_vcpu *vcpu, u32 msr, u64 data)
int	kvm_mtrr_set_msr (struct kvm_vcpu *vcpu, u32 msr, u64 data)
int	kvm_mtrr_get_msr (struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)
void	kvm_vcpu_mtrr_init (struct kvm_vcpu *vcpu)
static bool	mtrr_lookup_fixed_start (struct mtrr_iter *iter)
static bool	match_var_range (struct mtrr_iter *iter, struct kvm_mtrr_range *range)
static void	__mtrr_lookup_var_next (struct mtrr_iter *iter)
static void	mtrr_lookup_var_start (struct mtrr_iter *iter)
static void	mtrr_lookup_fixed_next (struct mtrr_iter *iter)
static void	mtrr_lookup_var_next (struct mtrr_iter *iter)
static void	mtrr_lookup_start (struct mtrr_iter *iter)
static void	mtrr_lookup_init (struct mtrr_iter *iter, struct kvm_mtrr *mtrr_state, u64 start, u64 end)
static bool	mtrr_lookup_okay (struct mtrr_iter *iter)
static void	mtrr_lookup_next (struct mtrr_iter *iter)
u8	kvm_mtrr_get_guest_memory_type (struct kvm_vcpu *vcpu, gfn_t gfn)
	EXPORT_SYMBOL_GPL (kvm_mtrr_get_guest_memory_type)
bool	kvm_mtrr_check_gfn_range_consistency (struct kvm_vcpu *vcpu, gfn_t gfn, int page_num)

Variables
static struct fixed_mtrr_segment	fixed_seg_table []

Macro Definition Documentation

IA32_MTRR_DEF_TYPE_E

#define IA32_MTRR_DEF_TYPE_E   (1ULL << 11)

Definition at line 24 of file mtrr.c.

IA32_MTRR_DEF_TYPE_FE

#define IA32_MTRR_DEF_TYPE_FE   (1ULL << 10)

Definition at line 25 of file mtrr.c.

IA32_MTRR_DEF_TYPE_TYPE_MASK

#define IA32_MTRR_DEF_TYPE_TYPE_MASK   (0xff)

Definition at line 26 of file mtrr.c.

mtrr_for_each_mem_type

#define mtrr_for_each_mem_type	(		_iter_,
			_mtrr_,
			_gpa_start_,
			_gpa_end_
	)

Value:

    for (mtrr_lookup_init(_iter_, _mtrr_, _gpa_start_, _gpa_end_); \
         mtrr_lookup_okay(_iter_); mtrr_lookup_next(_iter_))

Definition at line 610 of file mtrr.c.

pr_fmt

#define pr_fmt

(

fmt

)

KBUILD_MODNAME ": " fmt

Definition at line 16 of file mtrr.c.

Function Documentation

__mtrr_lookup_var_next()

static void __mtrr_lookup_var_next ( struct mtrr_iter *  iter )

static

Definition at line 513 of file mtrr.c.

{
    struct kvm_mtrr *mtrr_state = iter->mtrr_state;
 
    list_for_each_entry_continue(iter->range, &mtrr_state->head, node)
        if (match_var_range(iter, iter->range))
            return;
 
    iter->range = NULL;
    iter->partial_map |= iter->start_max < iter->end;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EXPORT_SYMBOL_GPL()

EXPORT_SYMBOL_GPL

(

kvm_mtrr_get_guest_memory_type

)

fixed_msr_to_range()

static bool fixed_msr_to_range ( u32  msr, u64 *  start, u64 *  end  )

static

Definition at line 250 of file mtrr.c.

{
    int seg, unit;
 
    if (!fixed_msr_to_seg_unit(msr, &seg, &unit))
        return false;
 
    fixed_mtrr_seg_unit_range(seg, unit, start, end);
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fixed_msr_to_range_index()

static int fixed_msr_to_range_index ( u32  msr )

static

Definition at line 261 of file mtrr.c.

{
    int seg, unit;
 
    if (!fixed_msr_to_seg_unit(msr, &seg, &unit))
        return -1;
 
    return fixed_mtrr_seg_unit_range_index(seg, unit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fixed_msr_to_seg_unit()

static bool fixed_msr_to_seg_unit ( u32  msr, int *  seg, int *  unit  )

static

Definition at line 194 of file mtrr.c.

{
    switch (msr) {
    case MSR_MTRRfix64K_00000:
        *seg = 0;
        *unit = 0;
        break;
    case MSR_MTRRfix16K_80000 ... MSR_MTRRfix16K_A0000:
        *seg = 1;
        *unit = array_index_nospec(
            msr - MSR_MTRRfix16K_80000,
            MSR_MTRRfix16K_A0000 - MSR_MTRRfix16K_80000 + 1);
        break;
    case MSR_MTRRfix4K_C0000 ... MSR_MTRRfix4K_F8000:
        *seg = 2;
        *unit = array_index_nospec(
            msr - MSR_MTRRfix4K_C0000,
            MSR_MTRRfix4K_F8000 - MSR_MTRRfix4K_C0000 + 1);
        break;
    default:
        return false;
    }
 
    return true;
}

Here is the caller graph for this function:

fixed_mtrr_addr_seg_to_range_index()

static int fixed_mtrr_addr_seg_to_range_index ( u64  addr, int  seg  )

static

Definition at line 285 of file mtrr.c.

{
    struct fixed_mtrr_segment *mtrr_seg;
    int index;
 
    mtrr_seg = &fixed_seg_table[seg];
    index = mtrr_seg->range_start;
    index += (addr - mtrr_seg->start) >> mtrr_seg->range_shift;
    return index;
}

Here is the caller graph for this function:

fixed_mtrr_addr_to_seg()

static int fixed_mtrr_addr_to_seg ( u64  addr )

static

Definition at line 271 of file mtrr.c.

{
    struct fixed_mtrr_segment *mtrr_seg;
    int seg, seg_num = ARRAY_SIZE(fixed_seg_table);
 
    for (seg = 0; seg < seg_num; seg++) {
        mtrr_seg = &fixed_seg_table[seg];
        if (mtrr_seg->start <= addr && addr < mtrr_seg->end)
            return seg;
    }
 
    return -1;
}

Here is the caller graph for this function:

fixed_mtrr_is_enabled()

static bool fixed_mtrr_is_enabled ( struct kvm_mtrr *  mtrr_state )

static

Definition at line 109 of file mtrr.c.

{
    return !!(mtrr_state->deftype & IA32_MTRR_DEF_TYPE_FE);
}

Here is the caller graph for this function:

fixed_mtrr_range_end_addr()

static u64 fixed_mtrr_range_end_addr ( int  seg, int  index  )

static

Definition at line 296 of file mtrr.c.

{
    struct fixed_mtrr_segment *mtrr_seg = &fixed_seg_table[seg];
    int pos = index - mtrr_seg->range_start;
 
    return mtrr_seg->start + ((pos + 1) << mtrr_seg->range_shift);
}

Here is the caller graph for this function:

fixed_mtrr_seg_end_range_index()

static int fixed_mtrr_seg_end_range_index ( int  seg )

static

Definition at line 241 of file mtrr.c.

{
    struct fixed_mtrr_segment *mtrr_seg = &fixed_seg_table[seg];
    int n;
 
    n = (mtrr_seg->end - mtrr_seg->start) >> mtrr_seg->range_shift;
    return mtrr_seg->range_start + n - 1;
}

Here is the caller graph for this function:

fixed_mtrr_seg_unit_range()

static void fixed_mtrr_seg_unit_range ( int  seg, int  unit, u64 *  start, u64 *  end  )

static

Definition at line 220 of file mtrr.c.

{
    struct fixed_mtrr_segment *mtrr_seg = &fixed_seg_table[seg];
    u64 unit_size = fixed_mtrr_seg_unit_size(seg);
 
    *start = mtrr_seg->start + unit * unit_size;
    *end = *start + unit_size;
    WARN_ON(*end > mtrr_seg->end);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fixed_mtrr_seg_unit_range_index()

static int fixed_mtrr_seg_unit_range_index ( int  seg, int  unit  )

static

Definition at line 230 of file mtrr.c.

{
    struct fixed_mtrr_segment *mtrr_seg = &fixed_seg_table[seg];
 
    WARN_ON(mtrr_seg->start + unit * fixed_mtrr_seg_unit_size(seg)
        > mtrr_seg->end);
 
    /* each unit has 8 ranges. */
    return mtrr_seg->range_start + 8 * unit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fixed_mtrr_seg_unit_size()

static u64 fixed_mtrr_seg_unit_size ( int  seg )

static

Definition at line 189 of file mtrr.c.

{
    return 8 << fixed_seg_table[seg].range_shift;
}

Here is the caller graph for this function:

is_mtrr_base_msr()

static bool is_mtrr_base_msr ( unsigned int  msr )

static

Definition at line 28 of file mtrr.c.

{
    /* MTRR base MSRs use even numbers, masks use odd numbers. */
    return !(msr & 0x1);
}

Here is the caller graph for this function:

kvm_mtrr_check_gfn_range_consistency()

bool kvm_mtrr_check_gfn_range_consistency	(	struct kvm_vcpu *	vcpu,
		gfn_t	gfn,
		int	page_num
	)

Definition at line 690 of file mtrr.c.

{
    struct kvm_mtrr *mtrr_state = &vcpu->arch.mtrr_state;
    struct mtrr_iter iter;
    u64 start, end;
    int type = -1;
 
    start = gfn_to_gpa(gfn);
    end = gfn_to_gpa(gfn + page_num);
    mtrr_for_each_mem_type(&iter, mtrr_state, start, end) {
        if (type == -1) {
            type = iter.mem_type;
            continue;
        }
 
        if (type != iter.mem_type)
            return false;
    }
 
    if (iter.mtrr_disabled)
        return true;
 
    if (!iter.partial_map)
        return true;
 
    if (type == -1)
        return true;
 
    return type == mtrr_default_type(mtrr_state);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_mtrr_get_guest_memory_type()

u8 kvm_mtrr_get_guest_memory_type	(	struct kvm_vcpu *	vcpu,
		gfn_t	gfn
	)

Definition at line 614 of file mtrr.c.

{
    struct kvm_mtrr *mtrr_state = &vcpu->arch.mtrr_state;
    struct mtrr_iter iter;
    u64 start, end;
    int type = -1;
    const int wt_wb_mask = (1 << MTRR_TYPE_WRBACK)
                   | (1 << MTRR_TYPE_WRTHROUGH);
 
    start = gfn_to_gpa(gfn);
    end = start + PAGE_SIZE;
 
    mtrr_for_each_mem_type(&iter, mtrr_state, start, end) {
        int curr_type = iter.mem_type;
 
        /*
         * Please refer to Intel SDM Volume 3: 11.11.4.1 MTRR
         * Precedences.
         */
 
        if (type == -1) {
            type = curr_type;
            continue;
        }
 
        /*
         * If two or more variable memory ranges match and the
         * memory types are identical, then that memory type is
         * used.
         */
        if (type == curr_type)
            continue;
 
        /*
         * If two or more variable memory ranges match and one of
         * the memory types is UC, the UC memory type used.
         */
        if (curr_type == MTRR_TYPE_UNCACHABLE)
            return MTRR_TYPE_UNCACHABLE;
 
        /*
         * If two or more variable memory ranges match and the
         * memory types are WT and WB, the WT memory type is used.
         */
        if (((1 << type) & wt_wb_mask) &&
              ((1 << curr_type) & wt_wb_mask)) {
            type = MTRR_TYPE_WRTHROUGH;
            continue;
        }
 
        /*
         * For overlaps not defined by the above rules, processor
         * behavior is undefined.
         */
 
        /* We use WB for this undefined behavior. :( */
        return MTRR_TYPE_WRBACK;
    }
 
    if (iter.mtrr_disabled)
        return mtrr_disabled_type(vcpu);
 
    /* not contained in any MTRRs. */
    if (type == -1)
        return mtrr_default_type(mtrr_state);
 
    /*
     * We just check one page, partially covered by MTRRs is
     * impossible.
     */
    WARN_ON(iter.partial_map);
 
    return type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_mtrr_get_msr()

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

Definition at line 397 of file mtrr.c.

{
    int index;
 
    /* MSR_MTRRcap is a readonly MSR. */
    if (msr == MSR_MTRRcap) {
        /*
         * SMRR = 0
         * WC = 1
         * FIX = 1
         * VCNT = KVM_NR_VAR_MTRR
         */
        *pdata = 0x500 | KVM_NR_VAR_MTRR;
        return 0;
    }
 
    if (!msr_mtrr_valid(msr))
        return 1;
 
    index = fixed_msr_to_range_index(msr);
    if (index >= 0) {
        *pdata = *(u64 *)&vcpu->arch.mtrr_state.fixed_ranges[index];
    } else if (msr == MSR_MTRRdefType) {
        *pdata = vcpu->arch.mtrr_state.deftype;
    } else {
        /* Variable MTRRs */
        if (is_mtrr_base_msr(msr))
            *pdata = var_mtrr_msr_to_range(vcpu, msr)->base;
        else
            *pdata = var_mtrr_msr_to_range(vcpu, msr)->mask;
 
        *pdata &= ~kvm_vcpu_reserved_gpa_bits_raw(vcpu);
    }
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_mtrr_set_msr()

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

Definition at line 378 of file mtrr.c.

{
    int index;
 
    if (!kvm_mtrr_valid(vcpu, msr, data))
        return 1;
 
    index = fixed_msr_to_range_index(msr);
    if (index >= 0)
        *(u64 *)&vcpu->arch.mtrr_state.fixed_ranges[index] = data;
    else if (msr == MSR_MTRRdefType)
        vcpu->arch.mtrr_state.deftype = data;
    else
        set_var_mtrr_msr(vcpu, msr, data);
 
    update_mtrr(vcpu, msr);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_mtrr_valid()

static bool kvm_mtrr_valid ( struct kvm_vcpu *  vcpu, u32  msr, u64  data  )

static

Definition at line 68 of file mtrr.c.

{
    int i;
    u64 mask;
 
    if (!msr_mtrr_valid(msr))
        return false;
 
    if (msr == MSR_MTRRdefType) {
        if (data & ~0xcff)
            return false;
        return valid_mtrr_type(data & 0xff);
    } else if (msr >= MSR_MTRRfix64K_00000 && msr <= MSR_MTRRfix4K_F8000) {
        for (i = 0; i < 8 ; i++)
            if (!valid_mtrr_type((data >> (i * 8)) & 0xff))
                return false;
        return true;
    }
 
    /* variable MTRRs */
    WARN_ON(!(msr >= MTRRphysBase_MSR(0) &&
          msr <= MTRRphysMask_MSR(KVM_NR_VAR_MTRR - 1)));
 
    mask = kvm_vcpu_reserved_gpa_bits_raw(vcpu);
    if ((msr & 1) == 0) {
        /* MTRR base */
        if (!valid_mtrr_type(data & 0xff))
            return false;
        mask |= 0xf00;
    } else
        /* MTRR mask */
        mask |= 0x7ff;
 
    return (data & mask) == 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_vcpu_mtrr_init()

void kvm_vcpu_mtrr_init

(

struct kvm_vcpu *

vcpu

)

Definition at line 434 of file mtrr.c.

{
    INIT_LIST_HEAD(&vcpu->arch.mtrr_state.head);
}

Here is the caller graph for this function:

match_var_range()

static bool match_var_range ( struct mtrr_iter *  iter, struct kvm_mtrr_range *  range  )

static

Definition at line 489 of file mtrr.c.

{
    u64 start, end;
 
    var_mtrr_range(range, &start, &end);
    if (!(start >= iter->end || end <= iter->start)) {
        iter->range = range;
 
        /*
         * the function is called when we do kvm_mtrr.head walking.
         * Range has the minimum base address which interleaves
         * [looker->start_max, looker->end).
         */
        iter->partial_map |= iter->start_max < start;
 
        /* update the max address has been covered. */
        iter->start_max = max(iter->start_max, end);
        return true;
    }
 
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

msr_mtrr_valid()

static bool msr_mtrr_valid ( unsigned  msr )

static

Definition at line 42 of file mtrr.c.

{
    switch (msr) {
    case MTRRphysBase_MSR(0) ... MTRRphysMask_MSR(KVM_NR_VAR_MTRR - 1):
    case MSR_MTRRfix64K_00000:
    case MSR_MTRRfix16K_80000:
    case MSR_MTRRfix16K_A0000:
    case MSR_MTRRfix4K_C0000:
    case MSR_MTRRfix4K_C8000:
    case MSR_MTRRfix4K_D0000:
    case MSR_MTRRfix4K_D8000:
    case MSR_MTRRfix4K_E0000:
    case MSR_MTRRfix4K_E8000:
    case MSR_MTRRfix4K_F0000:
    case MSR_MTRRfix4K_F8000:
    case MSR_MTRRdefType:
        return true;
    }
    return false;
}

Here is the caller graph for this function:

mtrr_default_type()

static u8 mtrr_default_type ( struct kvm_mtrr *  mtrr_state )

static

Definition at line 114 of file mtrr.c.

{
    return mtrr_state->deftype & IA32_MTRR_DEF_TYPE_TYPE_MASK;
}

Here is the caller graph for this function:

mtrr_disabled_type()

static u8 mtrr_disabled_type ( struct kvm_vcpu *  vcpu )

static

Definition at line 119 of file mtrr.c.

{
    /*
     * Intel SDM 11.11.2.2: all MTRRs are disabled when
     * IA32_MTRR_DEF_TYPE.E bit is cleared, and the UC
     * memory type is applied to all of physical memory.
     *
     * However, virtual machines can be run with CPUID such that
     * there are no MTRRs.  In that case, the firmware will never
     * enable MTRRs and it is obviously undesirable to run the
     * guest entirely with UC memory and we use WB.
     */
    if (guest_cpuid_has(vcpu, X86_FEATURE_MTRR))
        return MTRR_TYPE_UNCACHABLE;
    else
        return MTRR_TYPE_WRBACK;
}

Here is the caller graph for this function:

mtrr_is_enabled()

static bool mtrr_is_enabled ( struct kvm_mtrr *  mtrr_state )

static

Definition at line 104 of file mtrr.c.

{
    return !!(mtrr_state->deftype & IA32_MTRR_DEF_TYPE_E);
}

Here is the caller graph for this function:

mtrr_lookup_fixed_next()

static void mtrr_lookup_fixed_next ( struct mtrr_iter *  iter )

static

Definition at line 537 of file mtrr.c.

{
    /* terminate the lookup. */
    if (fixed_mtrr_range_end_addr(iter->seg, iter->index) >= iter->end) {
        iter->fixed = false;
        iter->range = NULL;
        return;
    }
 
    iter->index++;
 
    /* have looked up for all fixed MTRRs. */
    if (iter->index >= ARRAY_SIZE(iter->mtrr_state->fixed_ranges))
        return mtrr_lookup_var_start(iter);
 
    /* switch to next segment. */
    if (iter->index > fixed_mtrr_seg_end_range_index(iter->seg))
        iter->seg++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mtrr_lookup_fixed_start()

static bool mtrr_lookup_fixed_start ( struct mtrr_iter *  iter )

static

Definition at line 471 of file mtrr.c.

{
    int seg, index;
 
    if (!fixed_mtrr_is_enabled(iter->mtrr_state))
        return false;
 
    seg = fixed_mtrr_addr_to_seg(iter->start);
    if (seg < 0)
        return false;
 
    iter->fixed = true;
    index = fixed_mtrr_addr_seg_to_range_index(iter->start, seg);
    iter->index = index;
    iter->seg = seg;
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mtrr_lookup_init()

static void mtrr_lookup_init ( struct mtrr_iter *  iter, struct kvm_mtrr *  mtrr_state, u64  start, u64  end  )

static

Definition at line 573 of file mtrr.c.

{
    iter->mtrr_state = mtrr_state;
    iter->start = start;
    iter->end = end;
    iter->mtrr_disabled = false;
    iter->partial_map = false;
    iter->fixed = false;
    iter->range = NULL;
 
    mtrr_lookup_start(iter);
}

Here is the call graph for this function:

mtrr_lookup_next()

static void mtrr_lookup_next ( struct mtrr_iter *  iter )

static

Definition at line 602 of file mtrr.c.

{
    if (iter->fixed)
        mtrr_lookup_fixed_next(iter);
    else
        mtrr_lookup_var_next(iter);
}

Here is the call graph for this function:

mtrr_lookup_okay()

static bool mtrr_lookup_okay ( struct mtrr_iter *  iter )

static

Definition at line 587 of file mtrr.c.

{
    if (iter->fixed) {
        iter->mem_type = iter->mtrr_state->fixed_ranges[iter->index];
        return true;
    }
 
    if (iter->range) {
        iter->mem_type = iter->range->base & 0xff;
        return true;
    }
 
    return false;
}

mtrr_lookup_start()

static void mtrr_lookup_start ( struct mtrr_iter *  iter )

static

Definition at line 562 of file mtrr.c.

{
    if (!mtrr_is_enabled(iter->mtrr_state)) {
        iter->mtrr_disabled = true;
        return;
    }
 
    if (!mtrr_lookup_fixed_start(iter))
        mtrr_lookup_var_start(iter);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mtrr_lookup_var_next()

static void mtrr_lookup_var_next ( struct mtrr_iter *  iter )

static

Definition at line 557 of file mtrr.c.

{
    __mtrr_lookup_var_next(iter);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mtrr_lookup_var_start()

static void mtrr_lookup_var_start ( struct mtrr_iter *  iter )

static

Definition at line 525 of file mtrr.c.

{
    struct kvm_mtrr *mtrr_state = iter->mtrr_state;
 
    iter->fixed = false;
    iter->start_max = iter->start;
    iter->range = NULL;
    iter->range = list_prepare_entry(iter->range, &mtrr_state->head, node);
 
    __mtrr_lookup_var_next(iter);
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_var_mtrr_msr()

static void set_var_mtrr_msr ( struct kvm_vcpu *  vcpu, u32  msr, u64  data  )

static

Definition at line 349 of file mtrr.c.

{
    struct kvm_mtrr *mtrr_state = &vcpu->arch.mtrr_state;
    struct kvm_mtrr_range *tmp, *cur;
 
    cur = var_mtrr_msr_to_range(vcpu, msr);
 
    /* remove the entry if it's in the list. */
    if (var_mtrr_range_is_valid(cur))
        list_del(&cur->node);
 
    /*
     * Set all illegal GPA bits in the mask, since those bits must
     * implicitly be 0.  The bits are then cleared when reading them.
     */
    if (is_mtrr_base_msr(msr))
        cur->base = data;
    else
        cur->mask = data | kvm_vcpu_reserved_gpa_bits_raw(vcpu);
 
    /* add it to the list if it's enabled. */
    if (var_mtrr_range_is_valid(cur)) {
        list_for_each_entry(tmp, &mtrr_state->head, node)
            if (cur->base >= tmp->base)
                break;
        list_add_tail(&cur->node, &tmp->node);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_mtrr()

static void update_mtrr ( struct kvm_vcpu *  vcpu, u32  msr  )

static

Definition at line 318 of file mtrr.c.

{
    struct kvm_mtrr *mtrr_state = &vcpu->arch.mtrr_state;
    gfn_t start, end;
 
    if (!kvm_mmu_honors_guest_mtrrs(vcpu->kvm))
        return;
 
    if (!mtrr_is_enabled(mtrr_state) && msr != MSR_MTRRdefType)
        return;
 
    /* fixed MTRRs. */
    if (fixed_msr_to_range(msr, &start, &end)) {
        if (!fixed_mtrr_is_enabled(mtrr_state))
            return;
    } else if (msr == MSR_MTRRdefType) {
        start = 0x0;
        end = ~0ULL;
    } else {
        /* variable range MTRRs. */
        var_mtrr_range(var_mtrr_msr_to_range(vcpu, msr), &start, &end);
    }
 
    kvm_zap_gfn_range(vcpu->kvm, gpa_to_gfn(start), gpa_to_gfn(end));
}

Here is the call graph for this function:

Here is the caller graph for this function:

valid_mtrr_type()

static bool valid_mtrr_type ( unsigned  t )

static

Definition at line 63 of file mtrr.c.

{
    return t < 8 && (1 << t) & 0x73; /* 0, 1, 4, 5, 6 */
}

Here is the caller graph for this function:

var_mtrr_msr_to_range()

static struct kvm_mtrr_range* var_mtrr_msr_to_range ( struct kvm_vcpu *  vcpu, unsigned int  msr  )

static

Definition at line 34 of file mtrr.c.

{
    int index = (msr - MTRRphysBase_MSR(0)) / 2;
 
    return &vcpu->arch.mtrr_state.var_ranges[index];
}

Here is the caller graph for this function:

var_mtrr_range()

static void var_mtrr_range ( struct kvm_mtrr_range *  range, u64 *  start, u64 *  end  )

static

Definition at line 304 of file mtrr.c.

{
    u64 mask;
 
    *start = range->base & PAGE_MASK;
 
    mask = range->mask & PAGE_MASK;
 
    /* This cannot overflow because writing to the reserved bits of
     * variable MTRRs causes a #GP.
     */
    *end = (*start | ~mask) + 1;
}

Here is the caller graph for this function:

var_mtrr_range_is_valid()

static bool var_mtrr_range_is_valid ( struct kvm_mtrr_range *  range )

static

Definition at line 344 of file mtrr.c.

{
    return (range->mask & (1 << 11)) != 0;
}

Here is the caller graph for this function:

Variable Documentation

fixed_seg_table

struct fixed_mtrr_segment fixed_seg_table[]

static

Initial value:

= {
    
    {
        .start = 0x0,
        .end = 0x80000,
        .range_shift = 16, 
        .range_start = 0,
    },
 
    
    {
        .start = 0x80000,
        .end = 0xc0000,
        .range_shift = 14, 
        .range_start = 8,
    },
 
    
    {
        .start = 0xc0000,
        .end = 0x100000,
        .range_shift = 12, 
        .range_start = 24,
    }
}

Definition at line 119 of file mtrr.c.