2008-07-22 23:27:11 +04:00
|
|
|
/*
|
2007-10-10 19:16:19 +04:00
|
|
|
* Kernel-based Virtual Machine driver for Linux
|
|
|
|
*
|
|
|
|
* This header defines architecture specific interfaces, x86 version
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
|
|
* the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2008-10-23 09:26:29 +04:00
|
|
|
#ifndef _ASM_X86_KVM_HOST_H
|
|
|
|
#define _ASM_X86_KVM_HOST_H
|
2007-10-10 19:16:19 +04:00
|
|
|
|
2007-10-20 11:34:38 +04:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/mm.h>
|
2008-07-25 18:24:52 +04:00
|
|
|
#include <linux/mmu_notifier.h>
|
2007-10-20 11:34:38 +04:00
|
|
|
|
|
|
|
#include <linux/kvm.h>
|
|
|
|
#include <linux/kvm_para.h>
|
2007-12-16 12:02:48 +03:00
|
|
|
#include <linux/kvm_types.h>
|
2007-10-20 11:34:38 +04:00
|
|
|
|
2008-06-03 18:17:31 +04:00
|
|
|
#include <asm/pvclock-abi.h>
|
2007-12-04 00:30:25 +03:00
|
|
|
#include <asm/desc.h>
|
2008-10-09 12:01:54 +04:00
|
|
|
#include <asm/mtrr.h>
|
2007-12-04 00:30:25 +03:00
|
|
|
|
2008-03-21 13:38:23 +03:00
|
|
|
#define KVM_MAX_VCPUS 16
|
|
|
|
#define KVM_MEMORY_SLOTS 32
|
|
|
|
/* memory slots that does not exposed to userspace */
|
|
|
|
#define KVM_PRIVATE_MEM_SLOTS 4
|
|
|
|
|
|
|
|
#define KVM_PIO_PAGE_OFFSET 1
|
2008-05-30 18:05:55 +04:00
|
|
|
#define KVM_COALESCED_MMIO_PAGE_OFFSET 2
|
2008-03-21 13:38:23 +03:00
|
|
|
|
2007-11-19 09:33:37 +03:00
|
|
|
#define CR3_PAE_RESERVED_BITS ((X86_CR3_PWT | X86_CR3_PCD) - 1)
|
|
|
|
#define CR3_NONPAE_RESERVED_BITS ((PAGE_SIZE-1) & ~(X86_CR3_PWT | X86_CR3_PCD))
|
2008-03-23 11:02:34 +03:00
|
|
|
#define CR3_L_MODE_RESERVED_BITS (CR3_NONPAE_RESERVED_BITS | \
|
|
|
|
0xFFFFFF0000000000ULL)
|
2007-11-19 09:33:37 +03:00
|
|
|
|
2008-03-23 11:02:34 +03:00
|
|
|
#define KVM_GUEST_CR0_MASK \
|
2007-11-19 09:33:37 +03:00
|
|
|
(X86_CR0_PG | X86_CR0_PE | X86_CR0_WP | X86_CR0_NE \
|
|
|
|
| X86_CR0_NW | X86_CR0_CD)
|
2008-03-23 11:02:34 +03:00
|
|
|
#define KVM_VM_CR0_ALWAYS_ON \
|
2007-11-19 09:33:37 +03:00
|
|
|
(X86_CR0_PG | X86_CR0_PE | X86_CR0_WP | X86_CR0_NE | X86_CR0_TS \
|
|
|
|
| X86_CR0_MP)
|
2008-03-23 11:02:34 +03:00
|
|
|
#define KVM_GUEST_CR4_MASK \
|
2007-11-19 09:33:37 +03:00
|
|
|
(X86_CR4_VME | X86_CR4_PSE | X86_CR4_PAE | X86_CR4_PGE | X86_CR4_VMXE)
|
|
|
|
#define KVM_PMODE_VM_CR4_ALWAYS_ON (X86_CR4_PAE | X86_CR4_VMXE)
|
|
|
|
#define KVM_RMODE_VM_CR4_ALWAYS_ON (X86_CR4_VME | X86_CR4_PAE | X86_CR4_VMXE)
|
|
|
|
|
|
|
|
#define INVALID_PAGE (~(hpa_t)0)
|
|
|
|
#define UNMAPPED_GVA (~(gpa_t)0)
|
|
|
|
|
2008-02-23 17:44:30 +03:00
|
|
|
/* shadow tables are PAE even on non-PAE hosts */
|
|
|
|
#define KVM_HPAGE_SHIFT 21
|
|
|
|
#define KVM_HPAGE_SIZE (1UL << KVM_HPAGE_SHIFT)
|
|
|
|
#define KVM_HPAGE_MASK (~(KVM_HPAGE_SIZE - 1))
|
|
|
|
|
|
|
|
#define KVM_PAGES_PER_HPAGE (KVM_HPAGE_SIZE / PAGE_SIZE)
|
|
|
|
|
2007-11-19 09:33:37 +03:00
|
|
|
#define DE_VECTOR 0
|
2008-07-13 15:40:55 +04:00
|
|
|
#define DB_VECTOR 1
|
2008-07-14 14:28:51 +04:00
|
|
|
#define BP_VECTOR 3
|
|
|
|
#define OF_VECTOR 4
|
|
|
|
#define BR_VECTOR 5
|
2007-11-19 09:33:37 +03:00
|
|
|
#define UD_VECTOR 6
|
|
|
|
#define NM_VECTOR 7
|
|
|
|
#define DF_VECTOR 8
|
|
|
|
#define TS_VECTOR 10
|
|
|
|
#define NP_VECTOR 11
|
|
|
|
#define SS_VECTOR 12
|
|
|
|
#define GP_VECTOR 13
|
|
|
|
#define PF_VECTOR 14
|
2008-07-14 14:28:51 +04:00
|
|
|
#define MF_VECTOR 16
|
2008-04-09 16:15:30 +04:00
|
|
|
#define MC_VECTOR 18
|
2007-11-19 09:33:37 +03:00
|
|
|
|
|
|
|
#define SELECTOR_TI_MASK (1 << 2)
|
|
|
|
#define SELECTOR_RPL_MASK 0x03
|
|
|
|
|
|
|
|
#define IOPL_SHIFT 12
|
|
|
|
|
2007-12-14 04:54:20 +03:00
|
|
|
#define KVM_ALIAS_SLOTS 4
|
|
|
|
|
2007-12-14 04:41:22 +03:00
|
|
|
#define KVM_PERMILLE_MMU_PAGES 20
|
|
|
|
#define KVM_MIN_ALLOC_MMU_PAGES 64
|
2008-01-07 14:20:25 +03:00
|
|
|
#define KVM_MMU_HASH_SHIFT 10
|
|
|
|
#define KVM_NUM_MMU_PAGES (1 << KVM_MMU_HASH_SHIFT)
|
2007-12-14 04:41:22 +03:00
|
|
|
#define KVM_MIN_FREE_MMU_PAGES 5
|
|
|
|
#define KVM_REFILL_PAGES 25
|
|
|
|
#define KVM_MAX_CPUID_ENTRIES 40
|
2008-10-09 12:01:54 +04:00
|
|
|
#define KVM_NR_FIXED_MTRR_REGION 88
|
2008-05-26 21:06:35 +04:00
|
|
|
#define KVM_NR_VAR_MTRR 8
|
2007-12-14 04:41:22 +03:00
|
|
|
|
2007-11-14 15:38:21 +03:00
|
|
|
extern spinlock_t kvm_lock;
|
|
|
|
extern struct list_head vm_list;
|
|
|
|
|
2007-12-14 04:41:22 +03:00
|
|
|
struct kvm_vcpu;
|
|
|
|
struct kvm;
|
|
|
|
|
2008-06-27 21:58:02 +04:00
|
|
|
enum kvm_reg {
|
2007-11-19 09:56:05 +03:00
|
|
|
VCPU_REGS_RAX = 0,
|
|
|
|
VCPU_REGS_RCX = 1,
|
|
|
|
VCPU_REGS_RDX = 2,
|
|
|
|
VCPU_REGS_RBX = 3,
|
|
|
|
VCPU_REGS_RSP = 4,
|
|
|
|
VCPU_REGS_RBP = 5,
|
|
|
|
VCPU_REGS_RSI = 6,
|
|
|
|
VCPU_REGS_RDI = 7,
|
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
VCPU_REGS_R8 = 8,
|
|
|
|
VCPU_REGS_R9 = 9,
|
|
|
|
VCPU_REGS_R10 = 10,
|
|
|
|
VCPU_REGS_R11 = 11,
|
|
|
|
VCPU_REGS_R12 = 12,
|
|
|
|
VCPU_REGS_R13 = 13,
|
|
|
|
VCPU_REGS_R14 = 14,
|
|
|
|
VCPU_REGS_R15 = 15,
|
|
|
|
#endif
|
2008-06-27 21:58:02 +04:00
|
|
|
VCPU_REGS_RIP,
|
2007-11-19 09:56:05 +03:00
|
|
|
NR_VCPU_REGS
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
2008-05-27 17:26:01 +04:00
|
|
|
VCPU_SREG_ES,
|
2007-11-19 09:56:05 +03:00
|
|
|
VCPU_SREG_CS,
|
2008-05-27 17:26:01 +04:00
|
|
|
VCPU_SREG_SS,
|
2007-11-19 09:56:05 +03:00
|
|
|
VCPU_SREG_DS,
|
|
|
|
VCPU_SREG_FS,
|
|
|
|
VCPU_SREG_GS,
|
|
|
|
VCPU_SREG_TR,
|
|
|
|
VCPU_SREG_LDTR,
|
|
|
|
};
|
|
|
|
|
2007-12-16 12:02:48 +03:00
|
|
|
#include <asm/kvm_x86_emulate.h>
|
2007-11-19 09:56:05 +03:00
|
|
|
|
2007-12-14 04:41:22 +03:00
|
|
|
#define KVM_NR_MEM_OBJS 40
|
|
|
|
|
2008-03-21 13:38:23 +03:00
|
|
|
struct kvm_guest_debug {
|
|
|
|
int enabled;
|
|
|
|
unsigned long bp[4];
|
|
|
|
int singlestep;
|
|
|
|
};
|
|
|
|
|
2007-12-14 04:41:22 +03:00
|
|
|
/*
|
|
|
|
* We don't want allocation failures within the mmu code, so we preallocate
|
|
|
|
* enough memory for a single page fault in a cache.
|
|
|
|
*/
|
|
|
|
struct kvm_mmu_memory_cache {
|
|
|
|
int nobjs;
|
|
|
|
void *objects[KVM_NR_MEM_OBJS];
|
|
|
|
};
|
|
|
|
|
|
|
|
#define NR_PTE_CHAIN_ENTRIES 5
|
|
|
|
|
|
|
|
struct kvm_pte_chain {
|
|
|
|
u64 *parent_ptes[NR_PTE_CHAIN_ENTRIES];
|
|
|
|
struct hlist_node link;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* kvm_mmu_page_role, below, is defined as:
|
|
|
|
*
|
|
|
|
* bits 0:3 - total guest paging levels (2-4, or zero for real mode)
|
|
|
|
* bits 4:7 - page table level for this shadow (1-4)
|
|
|
|
* bits 8:9 - page table quadrant for 2-level guests
|
|
|
|
* bit 16 - "metaphysical" - gfn is not a real page (huge page/real mode)
|
|
|
|
* bits 17:19 - common access permissions for all ptes in this shadow page
|
|
|
|
*/
|
|
|
|
union kvm_mmu_page_role {
|
|
|
|
unsigned word;
|
|
|
|
struct {
|
2008-03-23 11:02:34 +03:00
|
|
|
unsigned glevels:4;
|
|
|
|
unsigned level:4;
|
|
|
|
unsigned quadrant:2;
|
|
|
|
unsigned pad_for_nice_hex_output:6;
|
|
|
|
unsigned metaphysical:1;
|
|
|
|
unsigned access:3;
|
2008-02-20 22:47:24 +03:00
|
|
|
unsigned invalid:1;
|
2007-12-14 04:41:22 +03:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
struct kvm_mmu_page {
|
|
|
|
struct list_head link;
|
|
|
|
struct hlist_node hash_link;
|
|
|
|
|
2008-12-02 03:32:04 +03:00
|
|
|
struct list_head oos_link;
|
|
|
|
|
2007-12-14 04:41:22 +03:00
|
|
|
/*
|
|
|
|
* The following two entries are used to key the shadow page in the
|
|
|
|
* hash table.
|
|
|
|
*/
|
|
|
|
gfn_t gfn;
|
|
|
|
union kvm_mmu_page_role role;
|
|
|
|
|
|
|
|
u64 *spt;
|
|
|
|
/* hold the gfn of each spte inside spt */
|
|
|
|
gfn_t *gfns;
|
2008-10-16 13:30:57 +04:00
|
|
|
/*
|
|
|
|
* One bit set per slot which has memory
|
|
|
|
* in this shadow page.
|
|
|
|
*/
|
|
|
|
DECLARE_BITMAP(slot_bitmap, KVM_MEMORY_SLOTS + KVM_PRIVATE_MEM_SLOTS);
|
2007-12-14 04:41:22 +03:00
|
|
|
int multimapped; /* More than one parent_pte? */
|
|
|
|
int root_count; /* Currently serving as active root */
|
2008-09-23 20:18:39 +04:00
|
|
|
bool unsync;
|
2008-12-02 03:32:04 +03:00
|
|
|
bool global;
|
2008-12-02 03:32:02 +03:00
|
|
|
unsigned int unsync_children;
|
2007-12-14 04:41:22 +03:00
|
|
|
union {
|
|
|
|
u64 *parent_pte; /* !multimapped */
|
|
|
|
struct hlist_head parent_ptes; /* multimapped, kvm_pte_chain */
|
|
|
|
};
|
2008-09-23 20:18:40 +04:00
|
|
|
DECLARE_BITMAP(unsync_child_bitmap, 512);
|
2007-12-14 04:41:22 +03:00
|
|
|
};
|
|
|
|
|
2008-08-11 21:01:49 +04:00
|
|
|
struct kvm_pv_mmu_op_buffer {
|
|
|
|
void *ptr;
|
|
|
|
unsigned len;
|
|
|
|
unsigned processed;
|
|
|
|
char buf[512] __aligned(sizeof(long));
|
|
|
|
};
|
|
|
|
|
2007-12-14 04:41:22 +03:00
|
|
|
/*
|
|
|
|
* x86 supports 3 paging modes (4-level 64-bit, 3-level 64-bit, and 2-level
|
|
|
|
* 32-bit). The kvm_mmu structure abstracts the details of the current mmu
|
|
|
|
* mode.
|
|
|
|
*/
|
|
|
|
struct kvm_mmu {
|
|
|
|
void (*new_cr3)(struct kvm_vcpu *vcpu);
|
|
|
|
int (*page_fault)(struct kvm_vcpu *vcpu, gva_t gva, u32 err);
|
|
|
|
void (*free)(struct kvm_vcpu *vcpu);
|
|
|
|
gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva);
|
|
|
|
void (*prefetch_page)(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_mmu_page *page);
|
2008-09-23 20:18:33 +04:00
|
|
|
int (*sync_page)(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_mmu_page *sp);
|
2008-09-23 20:18:35 +04:00
|
|
|
void (*invlpg)(struct kvm_vcpu *vcpu, gva_t gva);
|
2007-12-14 04:41:22 +03:00
|
|
|
hpa_t root_hpa;
|
|
|
|
int root_level;
|
|
|
|
int shadow_root_level;
|
|
|
|
|
|
|
|
u64 *pae_root;
|
|
|
|
};
|
|
|
|
|
2007-12-13 18:50:52 +03:00
|
|
|
struct kvm_vcpu_arch {
|
2007-10-20 11:34:38 +04:00
|
|
|
u64 host_tsc;
|
|
|
|
int interrupt_window_open;
|
|
|
|
unsigned long irq_summary; /* bit vector: 1 per word in irq_pending */
|
|
|
|
DECLARE_BITMAP(irq_pending, KVM_NR_INTERRUPTS);
|
2008-06-27 21:58:02 +04:00
|
|
|
/*
|
|
|
|
* rip and regs accesses must go through
|
|
|
|
* kvm_{register,rip}_{read,write} functions.
|
|
|
|
*/
|
|
|
|
unsigned long regs[NR_VCPU_REGS];
|
|
|
|
u32 regs_avail;
|
|
|
|
u32 regs_dirty;
|
2007-10-20 11:34:38 +04:00
|
|
|
|
|
|
|
unsigned long cr0;
|
|
|
|
unsigned long cr2;
|
|
|
|
unsigned long cr3;
|
|
|
|
unsigned long cr4;
|
|
|
|
unsigned long cr8;
|
|
|
|
u64 pdptrs[4]; /* pae */
|
|
|
|
u64 shadow_efer;
|
|
|
|
u64 apic_base;
|
|
|
|
struct kvm_lapic *apic; /* kernel irqchip context */
|
|
|
|
int mp_state;
|
|
|
|
int sipi_vector;
|
|
|
|
u64 ia32_misc_enable_msr;
|
2007-10-22 18:50:39 +04:00
|
|
|
bool tpr_access_reporting;
|
2007-10-20 11:34:38 +04:00
|
|
|
|
|
|
|
struct kvm_mmu mmu;
|
2008-08-11 21:01:49 +04:00
|
|
|
/* only needed in kvm_pv_mmu_op() path, but it's hot so
|
|
|
|
* put it here to avoid allocation */
|
|
|
|
struct kvm_pv_mmu_op_buffer mmu_op_buffer;
|
2007-10-20 11:34:38 +04:00
|
|
|
|
|
|
|
struct kvm_mmu_memory_cache mmu_pte_chain_cache;
|
|
|
|
struct kvm_mmu_memory_cache mmu_rmap_desc_cache;
|
|
|
|
struct kvm_mmu_memory_cache mmu_page_cache;
|
|
|
|
struct kvm_mmu_memory_cache mmu_page_header_cache;
|
|
|
|
|
|
|
|
gfn_t last_pt_write_gfn;
|
|
|
|
int last_pt_write_count;
|
|
|
|
u64 *last_pte_updated;
|
2008-05-15 14:51:35 +04:00
|
|
|
gfn_t last_pte_gfn;
|
2007-10-20 11:34:38 +04:00
|
|
|
|
2007-12-30 13:29:05 +03:00
|
|
|
struct {
|
2008-04-02 23:46:56 +04:00
|
|
|
gfn_t gfn; /* presumed gfn during guest pte update */
|
|
|
|
pfn_t pfn; /* pfn corresponding to that gfn */
|
2008-02-23 17:44:30 +03:00
|
|
|
int largepage;
|
2008-07-25 18:24:52 +04:00
|
|
|
unsigned long mmu_seq;
|
2007-12-30 13:29:05 +03:00
|
|
|
} update_pte;
|
|
|
|
|
2007-10-20 11:34:38 +04:00
|
|
|
struct i387_fxsave_struct host_fx_image;
|
|
|
|
struct i387_fxsave_struct guest_fx_image;
|
|
|
|
|
|
|
|
gva_t mmio_fault_cr2;
|
|
|
|
struct kvm_pio_request pio;
|
|
|
|
void *pio_data;
|
|
|
|
|
2007-11-25 14:41:11 +03:00
|
|
|
struct kvm_queued_exception {
|
|
|
|
bool pending;
|
|
|
|
bool has_error_code;
|
|
|
|
u8 nr;
|
|
|
|
u32 error_code;
|
|
|
|
} exception;
|
|
|
|
|
2008-07-03 16:17:01 +04:00
|
|
|
struct kvm_queued_interrupt {
|
|
|
|
bool pending;
|
|
|
|
u8 nr;
|
|
|
|
} interrupt;
|
|
|
|
|
2007-10-20 11:34:38 +04:00
|
|
|
struct {
|
|
|
|
int active;
|
|
|
|
u8 save_iopl;
|
|
|
|
struct kvm_save_segment {
|
|
|
|
u16 selector;
|
|
|
|
unsigned long base;
|
|
|
|
u32 limit;
|
|
|
|
u32 ar;
|
|
|
|
} tr, es, ds, fs, gs;
|
|
|
|
} rmode;
|
|
|
|
int halt_request; /* real mode on Intel only */
|
|
|
|
|
|
|
|
int cpuid_nent;
|
2007-11-21 18:10:04 +03:00
|
|
|
struct kvm_cpuid_entry2 cpuid_entries[KVM_MAX_CPUID_ENTRIES];
|
2007-10-20 11:34:38 +04:00
|
|
|
/* emulate context */
|
|
|
|
|
|
|
|
struct x86_emulate_ctxt emulate_ctxt;
|
2008-02-15 22:52:47 +03:00
|
|
|
|
|
|
|
gpa_t time;
|
2008-06-03 18:17:31 +04:00
|
|
|
struct pvclock_vcpu_time_info hv_clock;
|
|
|
|
unsigned int hv_clock_tsc_khz;
|
2008-02-15 22:52:47 +03:00
|
|
|
unsigned int time_offset;
|
|
|
|
struct page *time_page;
|
2008-05-15 05:52:48 +04:00
|
|
|
|
|
|
|
bool nmi_pending;
|
2008-07-02 10:28:55 +04:00
|
|
|
bool nmi_injected;
|
2008-09-26 11:30:49 +04:00
|
|
|
bool nmi_window_open;
|
2008-05-26 21:06:35 +04:00
|
|
|
|
2008-10-09 12:01:54 +04:00
|
|
|
struct mtrr_state_type mtrr_state;
|
|
|
|
u32 pat;
|
2007-10-20 11:34:38 +04:00
|
|
|
};
|
|
|
|
|
2007-12-14 04:54:20 +03:00
|
|
|
struct kvm_mem_alias {
|
|
|
|
gfn_t base_gfn;
|
|
|
|
unsigned long npages;
|
|
|
|
gfn_t target_gfn;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct kvm_arch{
|
|
|
|
int naliases;
|
|
|
|
struct kvm_mem_alias aliases[KVM_ALIAS_SLOTS];
|
2007-12-14 05:01:48 +03:00
|
|
|
|
|
|
|
unsigned int n_free_mmu_pages;
|
|
|
|
unsigned int n_requested_mmu_pages;
|
|
|
|
unsigned int n_alloc_mmu_pages;
|
|
|
|
struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES];
|
|
|
|
/*
|
|
|
|
* Hash table of struct kvm_mmu_page.
|
|
|
|
*/
|
|
|
|
struct list_head active_mmu_pages;
|
2008-07-28 20:26:26 +04:00
|
|
|
struct list_head assigned_dev_head;
|
2008-12-02 03:32:04 +03:00
|
|
|
struct list_head oos_global_pages;
|
2008-12-03 16:43:34 +03:00
|
|
|
struct iommu_domain *iommu_domain;
|
2007-12-14 05:17:34 +03:00
|
|
|
struct kvm_pic *vpic;
|
|
|
|
struct kvm_ioapic *vioapic;
|
2008-01-28 00:10:22 +03:00
|
|
|
struct kvm_pit *vpit;
|
2008-07-27 00:00:59 +04:00
|
|
|
struct hlist_head irq_ack_notifier_list;
|
2008-10-20 12:20:03 +04:00
|
|
|
int vapics_in_nmi_mode;
|
2007-12-14 05:20:16 +03:00
|
|
|
|
|
|
|
int round_robin_prev_vcpu;
|
|
|
|
unsigned int tss_addr;
|
|
|
|
struct page *apic_access_page;
|
2008-02-15 22:52:47 +03:00
|
|
|
|
|
|
|
gpa_t wall_clock;
|
2008-04-25 17:44:52 +04:00
|
|
|
|
|
|
|
struct page *ept_identity_pagetable;
|
|
|
|
bool ept_identity_pagetable_done;
|
2008-10-15 16:15:06 +04:00
|
|
|
|
|
|
|
unsigned long irq_sources_bitmap;
|
|
|
|
unsigned long irq_states[KVM_IOAPIC_NUM_PINS];
|
2007-12-14 04:54:20 +03:00
|
|
|
};
|
|
|
|
|
2007-12-14 05:23:23 +03:00
|
|
|
struct kvm_vm_stat {
|
|
|
|
u32 mmu_shadow_zapped;
|
|
|
|
u32 mmu_pte_write;
|
|
|
|
u32 mmu_pte_updated;
|
|
|
|
u32 mmu_pde_zapped;
|
|
|
|
u32 mmu_flooded;
|
|
|
|
u32 mmu_recycled;
|
2007-12-18 20:47:18 +03:00
|
|
|
u32 mmu_cache_miss;
|
2008-09-23 20:18:39 +04:00
|
|
|
u32 mmu_unsync;
|
2008-12-02 03:32:04 +03:00
|
|
|
u32 mmu_unsync_global;
|
2007-12-14 05:23:23 +03:00
|
|
|
u32 remote_tlb_flush;
|
2008-02-23 17:44:30 +03:00
|
|
|
u32 lpages;
|
2007-12-14 05:23:23 +03:00
|
|
|
};
|
|
|
|
|
2007-12-14 04:49:26 +03:00
|
|
|
struct kvm_vcpu_stat {
|
|
|
|
u32 pf_fixed;
|
|
|
|
u32 pf_guest;
|
|
|
|
u32 tlb_flush;
|
|
|
|
u32 invlpg;
|
|
|
|
|
|
|
|
u32 exits;
|
|
|
|
u32 io_exits;
|
|
|
|
u32 mmio_exits;
|
|
|
|
u32 signal_exits;
|
|
|
|
u32 irq_window_exits;
|
2008-05-15 14:23:25 +04:00
|
|
|
u32 nmi_window_exits;
|
2007-12-14 04:49:26 +03:00
|
|
|
u32 halt_exits;
|
|
|
|
u32 halt_wakeup;
|
|
|
|
u32 request_irq_exits;
|
2008-09-26 11:30:55 +04:00
|
|
|
u32 request_nmi_exits;
|
2007-12-14 04:49:26 +03:00
|
|
|
u32 irq_exits;
|
|
|
|
u32 host_state_reload;
|
|
|
|
u32 efer_reload;
|
|
|
|
u32 fpu_reload;
|
|
|
|
u32 insn_emulation;
|
|
|
|
u32 insn_emulation_fail;
|
2008-02-20 22:30:30 +03:00
|
|
|
u32 hypercalls;
|
2008-09-01 16:57:51 +04:00
|
|
|
u32 irq_injections;
|
2008-09-26 11:30:55 +04:00
|
|
|
u32 nmi_injections;
|
2007-12-14 04:49:26 +03:00
|
|
|
};
|
2007-12-13 18:50:52 +03:00
|
|
|
|
2007-12-04 00:30:25 +03:00
|
|
|
struct descriptor_table {
|
|
|
|
u16 limit;
|
|
|
|
unsigned long base;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
2007-11-19 09:40:47 +03:00
|
|
|
struct kvm_x86_ops {
|
|
|
|
int (*cpu_has_kvm_support)(void); /* __init */
|
|
|
|
int (*disabled_by_bios)(void); /* __init */
|
|
|
|
void (*hardware_enable)(void *dummy); /* __init */
|
|
|
|
void (*hardware_disable)(void *dummy);
|
|
|
|
void (*check_processor_compatibility)(void *rtn);
|
|
|
|
int (*hardware_setup)(void); /* __init */
|
|
|
|
void (*hardware_unsetup)(void); /* __exit */
|
2007-12-26 14:57:04 +03:00
|
|
|
bool (*cpu_has_accelerated_tpr)(void);
|
2007-11-19 09:40:47 +03:00
|
|
|
|
|
|
|
/* Create, but do not attach this VCPU */
|
|
|
|
struct kvm_vcpu *(*vcpu_create)(struct kvm *kvm, unsigned id);
|
|
|
|
void (*vcpu_free)(struct kvm_vcpu *vcpu);
|
|
|
|
int (*vcpu_reset)(struct kvm_vcpu *vcpu);
|
|
|
|
|
|
|
|
void (*prepare_guest_switch)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*vcpu_load)(struct kvm_vcpu *vcpu, int cpu);
|
|
|
|
void (*vcpu_put)(struct kvm_vcpu *vcpu);
|
|
|
|
|
|
|
|
int (*set_guest_debug)(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_debug_guest *dbg);
|
|
|
|
void (*guest_debug_pre)(struct kvm_vcpu *vcpu);
|
|
|
|
int (*get_msr)(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata);
|
|
|
|
int (*set_msr)(struct kvm_vcpu *vcpu, u32 msr_index, u64 data);
|
|
|
|
u64 (*get_segment_base)(struct kvm_vcpu *vcpu, int seg);
|
|
|
|
void (*get_segment)(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_segment *var, int seg);
|
2008-03-24 20:38:34 +03:00
|
|
|
int (*get_cpl)(struct kvm_vcpu *vcpu);
|
2007-11-19 09:40:47 +03:00
|
|
|
void (*set_segment)(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_segment *var, int seg);
|
|
|
|
void (*get_cs_db_l_bits)(struct kvm_vcpu *vcpu, int *db, int *l);
|
|
|
|
void (*decache_cr4_guest_bits)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*set_cr0)(struct kvm_vcpu *vcpu, unsigned long cr0);
|
|
|
|
void (*set_cr3)(struct kvm_vcpu *vcpu, unsigned long cr3);
|
|
|
|
void (*set_cr4)(struct kvm_vcpu *vcpu, unsigned long cr4);
|
|
|
|
void (*set_efer)(struct kvm_vcpu *vcpu, u64 efer);
|
|
|
|
void (*get_idt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt);
|
|
|
|
void (*set_idt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt);
|
|
|
|
void (*get_gdt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt);
|
|
|
|
void (*set_gdt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt);
|
|
|
|
unsigned long (*get_dr)(struct kvm_vcpu *vcpu, int dr);
|
|
|
|
void (*set_dr)(struct kvm_vcpu *vcpu, int dr, unsigned long value,
|
|
|
|
int *exception);
|
2008-06-27 21:58:02 +04:00
|
|
|
void (*cache_reg)(struct kvm_vcpu *vcpu, enum kvm_reg reg);
|
2007-11-19 09:40:47 +03:00
|
|
|
unsigned long (*get_rflags)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*set_rflags)(struct kvm_vcpu *vcpu, unsigned long rflags);
|
|
|
|
|
|
|
|
void (*tlb_flush)(struct kvm_vcpu *vcpu);
|
|
|
|
|
|
|
|
void (*run)(struct kvm_vcpu *vcpu, struct kvm_run *run);
|
|
|
|
int (*handle_exit)(struct kvm_run *run, struct kvm_vcpu *vcpu);
|
|
|
|
void (*skip_emulated_instruction)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*patch_hypercall)(struct kvm_vcpu *vcpu,
|
|
|
|
unsigned char *hypercall_addr);
|
|
|
|
int (*get_irq)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*set_irq)(struct kvm_vcpu *vcpu, int vec);
|
2007-11-25 14:41:11 +03:00
|
|
|
void (*queue_exception)(struct kvm_vcpu *vcpu, unsigned nr,
|
|
|
|
bool has_error_code, u32 error_code);
|
|
|
|
bool (*exception_injected)(struct kvm_vcpu *vcpu);
|
2007-11-19 09:40:47 +03:00
|
|
|
void (*inject_pending_irq)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*inject_pending_vectors)(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_run *run);
|
|
|
|
|
|
|
|
int (*set_tss_addr)(struct kvm *kvm, unsigned int addr);
|
2008-04-25 06:20:22 +04:00
|
|
|
int (*get_tdp_level)(void);
|
2008-10-09 12:01:57 +04:00
|
|
|
int (*get_mt_mask_shift)(void);
|
2007-11-19 09:40:47 +03:00
|
|
|
};
|
|
|
|
|
2007-11-14 15:09:30 +03:00
|
|
|
extern struct kvm_x86_ops *kvm_x86_ops;
|
|
|
|
|
2007-11-19 10:24:28 +03:00
|
|
|
int kvm_mmu_module_init(void);
|
|
|
|
void kvm_mmu_module_exit(void);
|
|
|
|
|
|
|
|
void kvm_mmu_destroy(struct kvm_vcpu *vcpu);
|
|
|
|
int kvm_mmu_create(struct kvm_vcpu *vcpu);
|
|
|
|
int kvm_mmu_setup(struct kvm_vcpu *vcpu);
|
|
|
|
void kvm_mmu_set_nonpresent_ptes(u64 trap_pte, u64 notrap_pte);
|
2008-04-25 17:13:50 +04:00
|
|
|
void kvm_mmu_set_base_ptes(u64 base_pte);
|
|
|
|
void kvm_mmu_set_mask_ptes(u64 user_mask, u64 accessed_mask,
|
2008-10-09 12:01:57 +04:00
|
|
|
u64 dirty_mask, u64 nx_mask, u64 x_mask, u64 mt_mask);
|
2007-11-19 10:24:28 +03:00
|
|
|
|
|
|
|
int kvm_mmu_reset_context(struct kvm_vcpu *vcpu);
|
|
|
|
void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot);
|
|
|
|
void kvm_mmu_zap_all(struct kvm *kvm);
|
2007-11-20 08:11:38 +03:00
|
|
|
unsigned int kvm_mmu_calculate_mmu_pages(struct kvm *kvm);
|
2007-11-19 10:24:28 +03:00
|
|
|
void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int kvm_nr_mmu_pages);
|
|
|
|
|
2008-02-07 15:47:43 +03:00
|
|
|
int load_pdptrs(struct kvm_vcpu *vcpu, unsigned long cr3);
|
|
|
|
|
2008-03-30 03:17:59 +04:00
|
|
|
int emulator_write_phys(struct kvm_vcpu *vcpu, gpa_t gpa,
|
2008-03-02 15:06:05 +03:00
|
|
|
const void *val, int bytes);
|
2008-02-22 20:21:37 +03:00
|
|
|
int kvm_pv_mmu_op(struct kvm_vcpu *vcpu, unsigned long bytes,
|
|
|
|
gpa_t addr, unsigned long *ret);
|
|
|
|
|
|
|
|
extern bool tdp_enabled;
|
2008-03-02 15:06:05 +03:00
|
|
|
|
2007-11-19 10:24:28 +03:00
|
|
|
enum emulation_result {
|
|
|
|
EMULATE_DONE, /* no further processing */
|
|
|
|
EMULATE_DO_MMIO, /* kvm_run filled with mmio request */
|
|
|
|
EMULATE_FAIL, /* can't emulate this instruction */
|
|
|
|
};
|
|
|
|
|
KVM: x86 emulator: Only allow VMCALL/VMMCALL trapped by #UD
When executing a test program called "crashme", we found the KVM guest cannot
survive more than ten seconds, then encounterd kernel panic. The basic concept
of "crashme" is generating random assembly code and trying to execute it.
After some fixes on emulator insn validity judgment, we found it's hard to
get the current emulator handle the invalid instructions correctly, for the
#UD trap for hypercall patching caused troubles. The problem is, if the opcode
itself was OK, but combination of opcode and modrm_reg was invalid, and one
operand of the opcode was memory (SrcMem or DstMem), the emulator will fetch
the memory operand first rather than checking the validity, and may encounter
an error there. For example, ".byte 0xfe, 0x34, 0xcd" has this problem.
In the patch, we simply check that if the invalid opcode wasn't vmcall/vmmcall,
then return from emulate_instruction() and inject a #UD to guest. With the
patch, the guest had been running for more than 12 hours.
Signed-off-by: Feng (Eric) Liu <eric.e.liu@intel.com>
Signed-off-by: Sheng Yang <sheng.yang@intel.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-01-02 09:49:22 +03:00
|
|
|
#define EMULTYPE_NO_DECODE (1 << 0)
|
|
|
|
#define EMULTYPE_TRAP_UD (1 << 1)
|
2007-11-19 10:24:28 +03:00
|
|
|
int emulate_instruction(struct kvm_vcpu *vcpu, struct kvm_run *run,
|
KVM: x86 emulator: Only allow VMCALL/VMMCALL trapped by #UD
When executing a test program called "crashme", we found the KVM guest cannot
survive more than ten seconds, then encounterd kernel panic. The basic concept
of "crashme" is generating random assembly code and trying to execute it.
After some fixes on emulator insn validity judgment, we found it's hard to
get the current emulator handle the invalid instructions correctly, for the
#UD trap for hypercall patching caused troubles. The problem is, if the opcode
itself was OK, but combination of opcode and modrm_reg was invalid, and one
operand of the opcode was memory (SrcMem or DstMem), the emulator will fetch
the memory operand first rather than checking the validity, and may encounter
an error there. For example, ".byte 0xfe, 0x34, 0xcd" has this problem.
In the patch, we simply check that if the invalid opcode wasn't vmcall/vmmcall,
then return from emulate_instruction() and inject a #UD to guest. With the
patch, the guest had been running for more than 12 hours.
Signed-off-by: Feng (Eric) Liu <eric.e.liu@intel.com>
Signed-off-by: Sheng Yang <sheng.yang@intel.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-01-02 09:49:22 +03:00
|
|
|
unsigned long cr2, u16 error_code, int emulation_type);
|
2007-11-19 10:24:28 +03:00
|
|
|
void kvm_report_emulation_failure(struct kvm_vcpu *cvpu, const char *context);
|
|
|
|
void realmode_lgdt(struct kvm_vcpu *vcpu, u16 size, unsigned long address);
|
|
|
|
void realmode_lidt(struct kvm_vcpu *vcpu, u16 size, unsigned long address);
|
|
|
|
void realmode_lmsw(struct kvm_vcpu *vcpu, unsigned long msw,
|
|
|
|
unsigned long *rflags);
|
|
|
|
|
|
|
|
unsigned long realmode_get_cr(struct kvm_vcpu *vcpu, int cr);
|
|
|
|
void realmode_set_cr(struct kvm_vcpu *vcpu, int cr, unsigned long value,
|
|
|
|
unsigned long *rflags);
|
2008-01-31 16:57:37 +03:00
|
|
|
void kvm_enable_efer_bits(u64);
|
2007-11-19 10:24:28 +03:00
|
|
|
int kvm_get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *data);
|
|
|
|
int kvm_set_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data);
|
|
|
|
|
|
|
|
struct x86_emulate_ctxt;
|
|
|
|
|
|
|
|
int kvm_emulate_pio(struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
|
|
|
|
int size, unsigned port);
|
|
|
|
int kvm_emulate_pio_string(struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
|
|
|
|
int size, unsigned long count, int down,
|
|
|
|
gva_t address, int rep, unsigned port);
|
|
|
|
void kvm_emulate_cpuid(struct kvm_vcpu *vcpu);
|
|
|
|
int kvm_emulate_halt(struct kvm_vcpu *vcpu);
|
|
|
|
int emulate_invlpg(struct kvm_vcpu *vcpu, gva_t address);
|
|
|
|
int emulate_clts(struct kvm_vcpu *vcpu);
|
|
|
|
int emulator_get_dr(struct x86_emulate_ctxt *ctxt, int dr,
|
|
|
|
unsigned long *dest);
|
|
|
|
int emulator_set_dr(struct x86_emulate_ctxt *ctxt, int dr,
|
|
|
|
unsigned long value);
|
|
|
|
|
2008-05-27 12:18:46 +04:00
|
|
|
void kvm_get_segment(struct kvm_vcpu *vcpu, struct kvm_segment *var, int seg);
|
|
|
|
int kvm_load_segment_descriptor(struct kvm_vcpu *vcpu, u16 selector,
|
|
|
|
int type_bits, int seg);
|
|
|
|
|
2008-03-25 00:14:53 +03:00
|
|
|
int kvm_task_switch(struct kvm_vcpu *vcpu, u16 tss_selector, int reason);
|
|
|
|
|
2008-02-24 12:20:43 +03:00
|
|
|
void kvm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0);
|
2008-04-01 18:44:56 +04:00
|
|
|
void kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3);
|
|
|
|
void kvm_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4);
|
|
|
|
void kvm_set_cr8(struct kvm_vcpu *vcpu, unsigned long cr8);
|
2008-02-24 12:20:43 +03:00
|
|
|
unsigned long kvm_get_cr8(struct kvm_vcpu *vcpu);
|
|
|
|
void kvm_lmsw(struct kvm_vcpu *vcpu, unsigned long msw);
|
2007-11-19 10:24:28 +03:00
|
|
|
void kvm_get_cs_db_l_bits(struct kvm_vcpu *vcpu, int *db, int *l);
|
|
|
|
|
|
|
|
int kvm_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata);
|
|
|
|
int kvm_set_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 data);
|
|
|
|
|
2007-11-25 14:41:11 +03:00
|
|
|
void kvm_queue_exception(struct kvm_vcpu *vcpu, unsigned nr);
|
|
|
|
void kvm_queue_exception_e(struct kvm_vcpu *vcpu, unsigned nr, u32 error_code);
|
2007-11-25 15:04:58 +03:00
|
|
|
void kvm_inject_page_fault(struct kvm_vcpu *vcpu, unsigned long cr2,
|
|
|
|
u32 error_code);
|
2007-11-25 14:41:11 +03:00
|
|
|
|
2008-10-06 09:48:45 +04:00
|
|
|
void kvm_pic_set_irq(void *opaque, int irq, int level);
|
|
|
|
|
2008-05-15 05:52:48 +04:00
|
|
|
void kvm_inject_nmi(struct kvm_vcpu *vcpu);
|
|
|
|
|
2007-11-19 10:24:28 +03:00
|
|
|
void fx_init(struct kvm_vcpu *vcpu);
|
|
|
|
|
|
|
|
int emulator_read_std(unsigned long addr,
|
|
|
|
void *val,
|
|
|
|
unsigned int bytes,
|
|
|
|
struct kvm_vcpu *vcpu);
|
|
|
|
int emulator_write_emulated(unsigned long addr,
|
|
|
|
const void *val,
|
|
|
|
unsigned int bytes,
|
|
|
|
struct kvm_vcpu *vcpu);
|
|
|
|
|
|
|
|
unsigned long segment_base(u16 selector);
|
|
|
|
|
2007-11-21 03:57:59 +03:00
|
|
|
void kvm_mmu_flush_tlb(struct kvm_vcpu *vcpu);
|
2007-11-19 10:24:28 +03:00
|
|
|
void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa,
|
2008-12-02 03:32:05 +03:00
|
|
|
const u8 *new, int bytes,
|
|
|
|
bool guest_initiated);
|
2007-11-19 10:24:28 +03:00
|
|
|
int kvm_mmu_unprotect_page_virt(struct kvm_vcpu *vcpu, gva_t gva);
|
|
|
|
void __kvm_mmu_free_some_pages(struct kvm_vcpu *vcpu);
|
|
|
|
int kvm_mmu_load(struct kvm_vcpu *vcpu);
|
|
|
|
void kvm_mmu_unload(struct kvm_vcpu *vcpu);
|
2008-09-23 20:18:34 +04:00
|
|
|
void kvm_mmu_sync_roots(struct kvm_vcpu *vcpu);
|
2008-12-02 03:32:04 +03:00
|
|
|
void kvm_mmu_sync_global(struct kvm_vcpu *vcpu);
|
2007-11-19 10:24:28 +03:00
|
|
|
|
|
|
|
int kvm_emulate_hypercall(struct kvm_vcpu *vcpu);
|
|
|
|
|
|
|
|
int kvm_fix_hypercall(struct kvm_vcpu *vcpu);
|
|
|
|
|
2007-10-28 19:48:59 +03:00
|
|
|
int kvm_mmu_page_fault(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code);
|
2008-09-23 20:18:35 +04:00
|
|
|
void kvm_mmu_invlpg(struct kvm_vcpu *vcpu, gva_t gva);
|
2007-10-20 11:34:38 +04:00
|
|
|
|
2008-02-07 15:47:41 +03:00
|
|
|
void kvm_enable_tdp(void);
|
2008-07-14 22:36:36 +04:00
|
|
|
void kvm_disable_tdp(void);
|
2008-02-07 15:47:41 +03:00
|
|
|
|
KVM: Portability: Move control register helper functions to x86.c
This patch moves the definitions of CR0_RESERVED_BITS,
CR4_RESERVED_BITS, and CR8_RESERVED_BITS along with the following
functions from kvm_main.c to x86.c:
set_cr0(), set_cr3(), set_cr4(), set_cr8(), get_cr8(), lmsw(),
load_pdptrs()
The static function wrapper inject_gp is duplicated in kvm_main.c and
x86.c for now, the version in kvm_main.c should disappear once the last
user of it is gone too.
The function load_pdptrs is no longer static, and now defined in x86.h
for the time being, until the last user of it is gone from kvm_main.c.
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Acked-by: Hollis Blanchard <hollisb@us.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2007-10-29 18:09:35 +03:00
|
|
|
int load_pdptrs(struct kvm_vcpu *vcpu, unsigned long cr3);
|
2007-10-30 20:44:25 +03:00
|
|
|
int complete_pio(struct kvm_vcpu *vcpu);
|
2007-11-19 10:08:31 +03:00
|
|
|
|
2008-10-03 18:40:32 +04:00
|
|
|
struct kvm_memory_slot *gfn_to_memslot_unaliased(struct kvm *kvm, gfn_t gfn);
|
|
|
|
|
2007-11-19 10:08:31 +03:00
|
|
|
static inline struct kvm_mmu_page *page_header(hpa_t shadow_page)
|
|
|
|
{
|
|
|
|
struct page *page = pfn_to_page(shadow_page >> PAGE_SHIFT);
|
|
|
|
|
|
|
|
return (struct kvm_mmu_page *)page_private(page);
|
|
|
|
}
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline u16 kvm_read_fs(void)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
u16 seg;
|
|
|
|
asm("mov %%fs, %0" : "=g"(seg));
|
|
|
|
return seg;
|
|
|
|
}
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline u16 kvm_read_gs(void)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
u16 seg;
|
|
|
|
asm("mov %%gs, %0" : "=g"(seg));
|
|
|
|
return seg;
|
|
|
|
}
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline u16 kvm_read_ldt(void)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
u16 ldt;
|
|
|
|
asm("sldt %0" : "=g"(ldt));
|
|
|
|
return ldt;
|
|
|
|
}
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline void kvm_load_fs(u16 sel)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
asm("mov %0, %%fs" : : "rm"(sel));
|
|
|
|
}
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline void kvm_load_gs(u16 sel)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
asm("mov %0, %%gs" : : "rm"(sel));
|
|
|
|
}
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline void kvm_load_ldt(u16 sel)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
asm("lldt %0" : : "rm"(sel));
|
|
|
|
}
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline void kvm_get_idt(struct descriptor_table *table)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
asm("sidt %0" : "=m"(*table));
|
|
|
|
}
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline void kvm_get_gdt(struct descriptor_table *table)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
asm("sgdt %0" : "=m"(*table));
|
|
|
|
}
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline unsigned long kvm_read_tr_base(void)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
u16 tr;
|
|
|
|
asm("str %0" : "=g"(tr));
|
|
|
|
return segment_base(tr);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
static inline unsigned long read_msr(unsigned long msr)
|
|
|
|
{
|
|
|
|
u64 value;
|
|
|
|
|
|
|
|
rdmsrl(msr, value);
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline void kvm_fx_save(struct i387_fxsave_struct *image)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
asm("fxsave (%0)":: "r" (image));
|
|
|
|
}
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline void kvm_fx_restore(struct i387_fxsave_struct *image)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
asm("fxrstor (%0)":: "r" (image));
|
|
|
|
}
|
|
|
|
|
2008-07-10 17:53:33 +04:00
|
|
|
static inline void kvm_fx_finit(void)
|
2007-11-19 10:08:31 +03:00
|
|
|
{
|
|
|
|
asm("finit");
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 get_rdx_init_val(void)
|
|
|
|
{
|
|
|
|
return 0x600; /* P6 family */
|
|
|
|
}
|
|
|
|
|
2007-11-25 15:12:03 +03:00
|
|
|
static inline void kvm_inject_gp(struct kvm_vcpu *vcpu, u32 error_code)
|
|
|
|
{
|
|
|
|
kvm_queue_exception_e(vcpu, GP_VECTOR, error_code);
|
|
|
|
}
|
|
|
|
|
2007-11-19 10:08:31 +03:00
|
|
|
#define MSR_IA32_TIME_STAMP_COUNTER 0x010
|
|
|
|
|
|
|
|
#define TSS_IOPB_BASE_OFFSET 0x66
|
|
|
|
#define TSS_BASE_SIZE 0x68
|
|
|
|
#define TSS_IOPB_SIZE (65536 / 8)
|
|
|
|
#define TSS_REDIRECTION_SIZE (256 / 8)
|
2008-03-23 11:02:34 +03:00
|
|
|
#define RMODE_TSS_SIZE \
|
|
|
|
(TSS_BASE_SIZE + TSS_REDIRECTION_SIZE + TSS_IOPB_SIZE + 1)
|
2007-12-04 01:15:26 +03:00
|
|
|
|
2008-03-25 00:14:53 +03:00
|
|
|
enum {
|
|
|
|
TASK_SWITCH_CALL = 0,
|
|
|
|
TASK_SWITCH_IRET = 1,
|
|
|
|
TASK_SWITCH_JMP = 2,
|
|
|
|
TASK_SWITCH_GATE = 3,
|
|
|
|
};
|
|
|
|
|
2008-05-13 14:23:38 +04:00
|
|
|
/*
|
|
|
|
* Hardware virtualization extension instructions may fault if a
|
|
|
|
* reboot turns off virtualization while processes are running.
|
|
|
|
* Trap the fault and ignore the instruction if that happens.
|
|
|
|
*/
|
|
|
|
asmlinkage void kvm_handle_fault_on_reboot(void);
|
|
|
|
|
|
|
|
#define __kvm_handle_fault_on_reboot(insn) \
|
|
|
|
"666: " insn "\n\t" \
|
2008-08-20 03:00:08 +04:00
|
|
|
".pushsection .fixup, \"ax\" \n" \
|
2008-05-13 14:23:38 +04:00
|
|
|
"667: \n\t" \
|
2008-08-14 22:25:47 +04:00
|
|
|
__ASM_SIZE(push) " $666b \n\t" \
|
2008-05-13 14:23:38 +04:00
|
|
|
"jmp kvm_handle_fault_on_reboot \n\t" \
|
|
|
|
".popsection \n\t" \
|
|
|
|
".pushsection __ex_table, \"a\" \n\t" \
|
2008-08-14 22:25:47 +04:00
|
|
|
_ASM_PTR " 666b, 667b \n\t" \
|
2008-05-13 14:23:38 +04:00
|
|
|
".popsection"
|
|
|
|
|
2008-07-25 18:24:52 +04:00
|
|
|
#define KVM_ARCH_WANT_MMU_NOTIFIER
|
|
|
|
int kvm_unmap_hva(struct kvm *kvm, unsigned long hva);
|
|
|
|
int kvm_age_hva(struct kvm *kvm, unsigned long hva);
|
|
|
|
|
2008-10-23 09:26:29 +04:00
|
|
|
#endif /* _ASM_X86_KVM_HOST_H */
|