home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / arch / x86 / include / asm / kvm_host.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  20.6 KB  |  760 lines
  1. /*
  2.  * Kernel-based Virtual Machine driver for Linux
  3.  *
  4.  * This header defines architecture specific interfaces, x86 version
  5.  *
  6.  * This work is licensed under the terms of the GNU GPL, version 2.  See
  7.  * the COPYING file in the top-level directory.
  8.  *
  9.  */
  10.  
  11. #ifndef _ASM_X86_KVM_HOST_H
  12. #define _ASM_X86_KVM_HOST_H
  13.  
  14. #include <linux/types.h>
  15. #include <linux/mm.h>
  16. #include <linux/mmu_notifier.h>
  17.  
  18. #include <linux/kvm.h>
  19. #include <linux/kvm_para.h>
  20. #include <linux/kvm_types.h>
  21.  
  22. #include <asm/pvclock-abi.h>
  23. #include <asm/desc.h>
  24.  
  25. #define KVM_MAX_VCPUS 16
  26. #define KVM_MEMORY_SLOTS 32
  27. /* memory slots that does not exposed to userspace */
  28. #define KVM_PRIVATE_MEM_SLOTS 4
  29.  
  30. #define KVM_PIO_PAGE_OFFSET 1
  31. #define KVM_COALESCED_MMIO_PAGE_OFFSET 2
  32.  
  33. #define CR3_PAE_RESERVED_BITS ((X86_CR3_PWT | X86_CR3_PCD) - 1)
  34. #define CR3_NONPAE_RESERVED_BITS ((PAGE_SIZE-1) & ~(X86_CR3_PWT | X86_CR3_PCD))
  35. #define CR3_L_MODE_RESERVED_BITS (CR3_NONPAE_RESERVED_BITS |    \
  36.                   0xFFFFFF0000000000ULL)
  37.  
  38. #define KVM_GUEST_CR0_MASK                   \
  39.     (X86_CR0_PG | X86_CR0_PE | X86_CR0_WP | X86_CR0_NE \
  40.      | X86_CR0_NW | X86_CR0_CD)
  41. #define KVM_VM_CR0_ALWAYS_ON                        \
  42.     (X86_CR0_PG | X86_CR0_PE | X86_CR0_WP | X86_CR0_NE | X86_CR0_TS \
  43.      | X86_CR0_MP)
  44. #define KVM_GUEST_CR4_MASK                        \
  45.     (X86_CR4_VME | X86_CR4_PSE | X86_CR4_PAE | X86_CR4_PGE | X86_CR4_VMXE)
  46. #define KVM_PMODE_VM_CR4_ALWAYS_ON (X86_CR4_PAE | X86_CR4_VMXE)
  47. #define KVM_RMODE_VM_CR4_ALWAYS_ON (X86_CR4_VME | X86_CR4_PAE | X86_CR4_VMXE)
  48.  
  49. #define INVALID_PAGE (~(hpa_t)0)
  50. #define UNMAPPED_GVA (~(gpa_t)0)
  51.  
  52. /* shadow tables are PAE even on non-PAE hosts */
  53. #define KVM_HPAGE_SHIFT 21
  54. #define KVM_HPAGE_SIZE (1UL << KVM_HPAGE_SHIFT)
  55. #define KVM_HPAGE_MASK (~(KVM_HPAGE_SIZE - 1))
  56.  
  57. #define KVM_PAGES_PER_HPAGE (KVM_HPAGE_SIZE / PAGE_SIZE)
  58.  
  59. #define DE_VECTOR 0
  60. #define DB_VECTOR 1
  61. #define BP_VECTOR 3
  62. #define OF_VECTOR 4
  63. #define BR_VECTOR 5
  64. #define UD_VECTOR 6
  65. #define NM_VECTOR 7
  66. #define DF_VECTOR 8
  67. #define TS_VECTOR 10
  68. #define NP_VECTOR 11
  69. #define SS_VECTOR 12
  70. #define GP_VECTOR 13
  71. #define PF_VECTOR 14
  72. #define MF_VECTOR 16
  73. #define MC_VECTOR 18
  74.  
  75. #define SELECTOR_TI_MASK (1 << 2)
  76. #define SELECTOR_RPL_MASK 0x03
  77.  
  78. #define IOPL_SHIFT 12
  79.  
  80. #define KVM_ALIAS_SLOTS 4
  81.  
  82. #define KVM_PERMILLE_MMU_PAGES 20
  83. #define KVM_MIN_ALLOC_MMU_PAGES 64
  84. #define KVM_MMU_HASH_SHIFT 10
  85. #define KVM_NUM_MMU_PAGES (1 << KVM_MMU_HASH_SHIFT)
  86. #define KVM_MIN_FREE_MMU_PAGES 5
  87. #define KVM_REFILL_PAGES 25
  88. #define KVM_MAX_CPUID_ENTRIES 40
  89. #define KVM_NR_VAR_MTRR 8
  90.  
  91. extern spinlock_t kvm_lock;
  92. extern struct list_head vm_list;
  93.  
  94. struct kvm_vcpu;
  95. struct kvm;
  96.  
  97. enum kvm_reg {
  98.     VCPU_REGS_RAX = 0,
  99.     VCPU_REGS_RCX = 1,
  100.     VCPU_REGS_RDX = 2,
  101.     VCPU_REGS_RBX = 3,
  102.     VCPU_REGS_RSP = 4,
  103.     VCPU_REGS_RBP = 5,
  104.     VCPU_REGS_RSI = 6,
  105.     VCPU_REGS_RDI = 7,
  106. #ifdef CONFIG_X86_64
  107.     VCPU_REGS_R8 = 8,
  108.     VCPU_REGS_R9 = 9,
  109.     VCPU_REGS_R10 = 10,
  110.     VCPU_REGS_R11 = 11,
  111.     VCPU_REGS_R12 = 12,
  112.     VCPU_REGS_R13 = 13,
  113.     VCPU_REGS_R14 = 14,
  114.     VCPU_REGS_R15 = 15,
  115. #endif
  116.     VCPU_REGS_RIP,
  117.     NR_VCPU_REGS
  118. };
  119.  
  120. enum {
  121.     VCPU_SREG_ES,
  122.     VCPU_SREG_CS,
  123.     VCPU_SREG_SS,
  124.     VCPU_SREG_DS,
  125.     VCPU_SREG_FS,
  126.     VCPU_SREG_GS,
  127.     VCPU_SREG_TR,
  128.     VCPU_SREG_LDTR,
  129. };
  130.  
  131. #include <asm/kvm_x86_emulate.h>
  132.  
  133. #define KVM_NR_MEM_OBJS 40
  134.  
  135. struct kvm_guest_debug {
  136.     int enabled;
  137.     unsigned long bp[4];
  138.     int singlestep;
  139. };
  140.  
  141. /*
  142.  * We don't want allocation failures within the mmu code, so we preallocate
  143.  * enough memory for a single page fault in a cache.
  144.  */
  145. struct kvm_mmu_memory_cache {
  146.     int nobjs;
  147.     void *objects[KVM_NR_MEM_OBJS];
  148. };
  149.  
  150. #define NR_PTE_CHAIN_ENTRIES 5
  151.  
  152. struct kvm_pte_chain {
  153.     u64 *parent_ptes[NR_PTE_CHAIN_ENTRIES];
  154.     struct hlist_node link;
  155. };
  156.  
  157. /*
  158.  * kvm_mmu_page_role, below, is defined as:
  159.  *
  160.  *   bits 0:3 - total guest paging levels (2-4, or zero for real mode)
  161.  *   bits 4:7 - page table level for this shadow (1-4)
  162.  *   bits 8:9 - page table quadrant for 2-level guests
  163.  *   bit   16 - "metaphysical" - gfn is not a real page (huge page/real mode)
  164.  *   bits 17:19 - common access permissions for all ptes in this shadow page
  165.  */
  166. union kvm_mmu_page_role {
  167.     unsigned word;
  168.     struct {
  169.         unsigned glevels:4;
  170.         unsigned level:4;
  171.         unsigned quadrant:2;
  172.         unsigned pad_for_nice_hex_output:6;
  173.         unsigned metaphysical:1;
  174.         unsigned access:3;
  175.         unsigned invalid:1;
  176.     };
  177. };
  178.  
  179. struct kvm_mmu_page {
  180.     struct list_head link;
  181.     struct hlist_node hash_link;
  182.  
  183.     /*
  184.      * The following two entries are used to key the shadow page in the
  185.      * hash table.
  186.      */
  187.     gfn_t gfn;
  188.     union kvm_mmu_page_role role;
  189.  
  190.     u64 *spt;
  191.     /* hold the gfn of each spte inside spt */
  192.     gfn_t *gfns;
  193.     /*
  194.      * One bit set per slot which has memory
  195.      * in this shadow page.
  196.      */
  197.     DECLARE_BITMAP(slot_bitmap, KVM_MEMORY_SLOTS + KVM_PRIVATE_MEM_SLOTS);
  198.     int multimapped;         /* More than one parent_pte? */
  199.     int root_count;          /* Currently serving as active root */
  200.     bool unsync;
  201.     bool unsync_children;
  202.     union {
  203.         u64 *parent_pte;               /* !multimapped */
  204.         struct hlist_head parent_ptes; /* multimapped, kvm_pte_chain */
  205.     };
  206.     DECLARE_BITMAP(unsync_child_bitmap, 512);
  207. };
  208.  
  209. struct kvm_pv_mmu_op_buffer {
  210.     void *ptr;
  211.     unsigned len;
  212.     unsigned processed;
  213.     char buf[512] __aligned(sizeof(long));
  214. };
  215.  
  216. /*
  217.  * x86 supports 3 paging modes (4-level 64-bit, 3-level 64-bit, and 2-level
  218.  * 32-bit).  The kvm_mmu structure abstracts the details of the current mmu
  219.  * mode.
  220.  */
  221. struct kvm_mmu {
  222.     void (*new_cr3)(struct kvm_vcpu *vcpu);
  223.     int (*page_fault)(struct kvm_vcpu *vcpu, gva_t gva, u32 err);
  224.     void (*free)(struct kvm_vcpu *vcpu);
  225.     gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva);
  226.     void (*prefetch_page)(struct kvm_vcpu *vcpu,
  227.                   struct kvm_mmu_page *page);
  228.     int (*sync_page)(struct kvm_vcpu *vcpu,
  229.              struct kvm_mmu_page *sp);
  230.     void (*invlpg)(struct kvm_vcpu *vcpu, gva_t gva);
  231.     hpa_t root_hpa;
  232.     int root_level;
  233.     int shadow_root_level;
  234.  
  235.     u64 *pae_root;
  236. };
  237.  
  238. struct kvm_vcpu_arch {
  239.     u64 host_tsc;
  240.     int interrupt_window_open;
  241.     unsigned long irq_summary; /* bit vector: 1 per word in irq_pending */
  242.     DECLARE_BITMAP(irq_pending, KVM_NR_INTERRUPTS);
  243.     /*
  244.      * rip and regs accesses must go through
  245.      * kvm_{register,rip}_{read,write} functions.
  246.      */
  247.     unsigned long regs[NR_VCPU_REGS];
  248.     u32 regs_avail;
  249.     u32 regs_dirty;
  250.  
  251.     unsigned long cr0;
  252.     unsigned long cr2;
  253.     unsigned long cr3;
  254.     unsigned long cr4;
  255.     unsigned long cr8;
  256.     u64 pdptrs[4]; /* pae */
  257.     u64 shadow_efer;
  258.     u64 apic_base;
  259.     struct kvm_lapic *apic;    /* kernel irqchip context */
  260.     int mp_state;
  261.     int sipi_vector;
  262.     u64 ia32_misc_enable_msr;
  263.     bool tpr_access_reporting;
  264.  
  265.     struct kvm_mmu mmu;
  266.     /* only needed in kvm_pv_mmu_op() path, but it's hot so
  267.      * put it here to avoid allocation */
  268.     struct kvm_pv_mmu_op_buffer mmu_op_buffer;
  269.  
  270.     struct kvm_mmu_memory_cache mmu_pte_chain_cache;
  271.     struct kvm_mmu_memory_cache mmu_rmap_desc_cache;
  272.     struct kvm_mmu_memory_cache mmu_page_cache;
  273.     struct kvm_mmu_memory_cache mmu_page_header_cache;
  274.  
  275.     gfn_t last_pt_write_gfn;
  276.     int   last_pt_write_count;
  277.     u64  *last_pte_updated;
  278.     gfn_t last_pte_gfn;
  279.  
  280.     struct {
  281.         gfn_t gfn;    /* presumed gfn during guest pte update */
  282.         pfn_t pfn;    /* pfn corresponding to that gfn */
  283.         int largepage;
  284.         unsigned long mmu_seq;
  285.     } update_pte;
  286.  
  287.     struct i387_fxsave_struct host_fx_image;
  288.     struct i387_fxsave_struct guest_fx_image;
  289.  
  290.     gva_t mmio_fault_cr2;
  291.     struct kvm_pio_request pio;
  292.     void *pio_data;
  293.  
  294.     struct kvm_queued_exception {
  295.         bool pending;
  296.         bool has_error_code;
  297.         u8 nr;
  298.         u32 error_code;
  299.     } exception;
  300.  
  301.     struct kvm_queued_interrupt {
  302.         bool pending;
  303.         u8 nr;
  304.     } interrupt;
  305.  
  306.     struct {
  307.         int active;
  308.         u8 save_iopl;
  309.         struct kvm_save_segment {
  310.             u16 selector;
  311.             unsigned long base;
  312.             u32 limit;
  313.             u32 ar;
  314.         } tr, es, ds, fs, gs;
  315.     } rmode;
  316.     int halt_request; /* real mode on Intel only */
  317.  
  318.     int cpuid_nent;
  319.     struct kvm_cpuid_entry2 cpuid_entries[KVM_MAX_CPUID_ENTRIES];
  320.     /* emulate context */
  321.  
  322.     struct x86_emulate_ctxt emulate_ctxt;
  323.  
  324.     gpa_t time;
  325.     struct pvclock_vcpu_time_info hv_clock;
  326.     unsigned int hv_clock_tsc_khz;
  327.     unsigned int time_offset;
  328.     struct page *time_page;
  329.  
  330.     bool nmi_pending;
  331.     bool nmi_injected;
  332.  
  333.     u64 mtrr[0x100];
  334. };
  335.  
  336. struct kvm_mem_alias {
  337.     gfn_t base_gfn;
  338.     unsigned long npages;
  339.     gfn_t target_gfn;
  340. };
  341.  
  342. struct kvm_arch{
  343.     int naliases;
  344.     struct kvm_mem_alias aliases[KVM_ALIAS_SLOTS];
  345.  
  346.     unsigned int n_free_mmu_pages;
  347.     unsigned int n_requested_mmu_pages;
  348.     unsigned int n_alloc_mmu_pages;
  349.     struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES];
  350.     /*
  351.      * Hash table of struct kvm_mmu_page.
  352.      */
  353.     struct list_head active_mmu_pages;
  354.     struct list_head assigned_dev_head;
  355.     struct dmar_domain *intel_iommu_domain;
  356.     struct kvm_pic *vpic;
  357.     struct kvm_ioapic *vioapic;
  358.     struct kvm_pit *vpit;
  359.     struct hlist_head irq_ack_notifier_list;
  360.  
  361.     int round_robin_prev_vcpu;
  362.     unsigned int tss_addr;
  363.     struct page *apic_access_page;
  364.  
  365.     gpa_t wall_clock;
  366.  
  367.     struct page *ept_identity_pagetable;
  368.     bool ept_identity_pagetable_done;
  369.  
  370.     unsigned long irq_sources_bitmap;
  371.     unsigned long irq_states[KVM_IOAPIC_NUM_PINS];
  372. };
  373.  
  374. struct kvm_vm_stat {
  375.     u32 mmu_shadow_zapped;
  376.     u32 mmu_pte_write;
  377.     u32 mmu_pte_updated;
  378.     u32 mmu_pde_zapped;
  379.     u32 mmu_flooded;
  380.     u32 mmu_recycled;
  381.     u32 mmu_cache_miss;
  382.     u32 mmu_unsync;
  383.     u32 remote_tlb_flush;
  384.     u32 lpages;
  385. };
  386.  
  387. struct kvm_vcpu_stat {
  388.     u32 pf_fixed;
  389.     u32 pf_guest;
  390.     u32 tlb_flush;
  391.     u32 invlpg;
  392.  
  393.     u32 exits;
  394.     u32 io_exits;
  395.     u32 mmio_exits;
  396.     u32 signal_exits;
  397.     u32 irq_window_exits;
  398.     u32 nmi_window_exits;
  399.     u32 halt_exits;
  400.     u32 halt_wakeup;
  401.     u32 request_irq_exits;
  402.     u32 irq_exits;
  403.     u32 host_state_reload;
  404.     u32 efer_reload;
  405.     u32 fpu_reload;
  406.     u32 insn_emulation;
  407.     u32 insn_emulation_fail;
  408.     u32 hypercalls;
  409.     u32 irq_injections;
  410. };
  411.  
  412. struct descriptor_table {
  413.     u16 limit;
  414.     unsigned long base;
  415. } __attribute__((packed));
  416.  
  417. struct kvm_x86_ops {
  418.     int (*cpu_has_kvm_support)(void);          /* __init */
  419.     int (*disabled_by_bios)(void);             /* __init */
  420.     void (*hardware_enable)(void *dummy);      /* __init */
  421.     void (*hardware_disable)(void *dummy);
  422.     void (*check_processor_compatibility)(void *rtn);
  423.     int (*hardware_setup)(void);               /* __init */
  424.     void (*hardware_unsetup)(void);            /* __exit */
  425.     bool (*cpu_has_accelerated_tpr)(void);
  426.  
  427.     /* Create, but do not attach this VCPU */
  428.     struct kvm_vcpu *(*vcpu_create)(struct kvm *kvm, unsigned id);
  429.     void (*vcpu_free)(struct kvm_vcpu *vcpu);
  430.     int (*vcpu_reset)(struct kvm_vcpu *vcpu);
  431.  
  432.     void (*prepare_guest_switch)(struct kvm_vcpu *vcpu);
  433.     void (*vcpu_load)(struct kvm_vcpu *vcpu, int cpu);
  434.     void (*vcpu_put)(struct kvm_vcpu *vcpu);
  435.  
  436.     int (*set_guest_debug)(struct kvm_vcpu *vcpu,
  437.                    struct kvm_debug_guest *dbg);
  438.     void (*guest_debug_pre)(struct kvm_vcpu *vcpu);
  439.     int (*get_msr)(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata);
  440.     int (*set_msr)(struct kvm_vcpu *vcpu, u32 msr_index, u64 data);
  441.     u64 (*get_segment_base)(struct kvm_vcpu *vcpu, int seg);
  442.     void (*get_segment)(struct kvm_vcpu *vcpu,
  443.                 struct kvm_segment *var, int seg);
  444.     int (*get_cpl)(struct kvm_vcpu *vcpu);
  445.     void (*set_segment)(struct kvm_vcpu *vcpu,
  446.                 struct kvm_segment *var, int seg);
  447.     void (*get_cs_db_l_bits)(struct kvm_vcpu *vcpu, int *db, int *l);
  448.     void (*decache_cr4_guest_bits)(struct kvm_vcpu *vcpu);
  449.     void (*set_cr0)(struct kvm_vcpu *vcpu, unsigned long cr0);
  450.     void (*set_cr3)(struct kvm_vcpu *vcpu, unsigned long cr3);
  451.     void (*set_cr4)(struct kvm_vcpu *vcpu, unsigned long cr4);
  452.     void (*set_efer)(struct kvm_vcpu *vcpu, u64 efer);
  453.     void (*get_idt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt);
  454.     void (*set_idt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt);
  455.     void (*get_gdt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt);
  456.     void (*set_gdt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt);
  457.     unsigned long (*get_dr)(struct kvm_vcpu *vcpu, int dr);
  458.     void (*set_dr)(struct kvm_vcpu *vcpu, int dr, unsigned long value,
  459.                int *exception);
  460.     void (*cache_reg)(struct kvm_vcpu *vcpu, enum kvm_reg reg);
  461.     unsigned long (*get_rflags)(struct kvm_vcpu *vcpu);
  462.     void (*set_rflags)(struct kvm_vcpu *vcpu, unsigned long rflags);
  463.  
  464.     void (*tlb_flush)(struct kvm_vcpu *vcpu);
  465.  
  466.     void (*run)(struct kvm_vcpu *vcpu, struct kvm_run *run);
  467.     int (*handle_exit)(struct kvm_run *run, struct kvm_vcpu *vcpu);
  468.     void (*skip_emulated_instruction)(struct kvm_vcpu *vcpu);
  469.     void (*patch_hypercall)(struct kvm_vcpu *vcpu,
  470.                 unsigned char *hypercall_addr);
  471.     int (*get_irq)(struct kvm_vcpu *vcpu);
  472.     void (*set_irq)(struct kvm_vcpu *vcpu, int vec);
  473.     void (*queue_exception)(struct kvm_vcpu *vcpu, unsigned nr,
  474.                 bool has_error_code, u32 error_code);
  475.     bool (*exception_injected)(struct kvm_vcpu *vcpu);
  476.     void (*inject_pending_irq)(struct kvm_vcpu *vcpu);
  477.     void (*inject_pending_vectors)(struct kvm_vcpu *vcpu,
  478.                        struct kvm_run *run);
  479.  
  480.     int (*set_tss_addr)(struct kvm *kvm, unsigned int addr);
  481.     int (*get_tdp_level)(void);
  482. };
  483.  
  484. extern struct kvm_x86_ops *kvm_x86_ops;
  485.  
  486. int kvm_mmu_module_init(void);
  487. void kvm_mmu_module_exit(void);
  488.  
  489. void kvm_mmu_destroy(struct kvm_vcpu *vcpu);
  490. int kvm_mmu_create(struct kvm_vcpu *vcpu);
  491. int kvm_mmu_setup(struct kvm_vcpu *vcpu);
  492. void kvm_mmu_set_nonpresent_ptes(u64 trap_pte, u64 notrap_pte);
  493. void kvm_mmu_set_base_ptes(u64 base_pte);
  494. void kvm_mmu_set_mask_ptes(u64 user_mask, u64 accessed_mask,
  495.         u64 dirty_mask, u64 nx_mask, u64 x_mask);
  496.  
  497. int kvm_mmu_reset_context(struct kvm_vcpu *vcpu);
  498. void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot);
  499. void kvm_mmu_zap_all(struct kvm *kvm);
  500. unsigned int kvm_mmu_calculate_mmu_pages(struct kvm *kvm);
  501. void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int kvm_nr_mmu_pages);
  502.  
  503. int load_pdptrs(struct kvm_vcpu *vcpu, unsigned long cr3);
  504.  
  505. int emulator_write_phys(struct kvm_vcpu *vcpu, gpa_t gpa,
  506.               const void *val, int bytes);
  507. int kvm_pv_mmu_op(struct kvm_vcpu *vcpu, unsigned long bytes,
  508.           gpa_t addr, unsigned long *ret);
  509.  
  510. extern bool tdp_enabled;
  511.  
  512. enum emulation_result {
  513.     EMULATE_DONE,       /* no further processing */
  514.     EMULATE_DO_MMIO,      /* kvm_run filled with mmio request */
  515.     EMULATE_FAIL,         /* can't emulate this instruction */
  516. };
  517.  
  518. #define EMULTYPE_NO_DECODE        (1 << 0)
  519. #define EMULTYPE_TRAP_UD        (1 << 1)
  520. int emulate_instruction(struct kvm_vcpu *vcpu, struct kvm_run *run,
  521.             unsigned long cr2, u16 error_code, int emulation_type);
  522. void kvm_report_emulation_failure(struct kvm_vcpu *cvpu, const char *context);
  523. void realmode_lgdt(struct kvm_vcpu *vcpu, u16 size, unsigned long address);
  524. void realmode_lidt(struct kvm_vcpu *vcpu, u16 size, unsigned long address);
  525. void realmode_lmsw(struct kvm_vcpu *vcpu, unsigned long msw,
  526.            unsigned long *rflags);
  527.  
  528. unsigned long realmode_get_cr(struct kvm_vcpu *vcpu, int cr);
  529. void realmode_set_cr(struct kvm_vcpu *vcpu, int cr, unsigned long value,
  530.              unsigned long *rflags);
  531. void kvm_enable_efer_bits(u64);
  532. int kvm_get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *data);
  533. int kvm_set_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data);
  534.  
  535. struct x86_emulate_ctxt;
  536.  
  537. int kvm_emulate_pio(struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
  538.              int size, unsigned port);
  539. int kvm_emulate_pio_string(struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
  540.                int size, unsigned long count, int down,
  541.                 gva_t address, int rep, unsigned port);
  542. void kvm_emulate_cpuid(struct kvm_vcpu *vcpu);
  543. int kvm_emulate_halt(struct kvm_vcpu *vcpu);
  544. int emulate_invlpg(struct kvm_vcpu *vcpu, gva_t address);
  545. int emulate_clts(struct kvm_vcpu *vcpu);
  546. int emulator_get_dr(struct x86_emulate_ctxt *ctxt, int dr,
  547.             unsigned long *dest);
  548. int emulator_set_dr(struct x86_emulate_ctxt *ctxt, int dr,
  549.             unsigned long value);
  550.  
  551. void kvm_get_segment(struct kvm_vcpu *vcpu, struct kvm_segment *var, int seg);
  552. int kvm_load_segment_descriptor(struct kvm_vcpu *vcpu, u16 selector,
  553.                 int type_bits, int seg);
  554.  
  555. int kvm_task_switch(struct kvm_vcpu *vcpu, u16 tss_selector, int reason);
  556.  
  557. void kvm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0);
  558. void kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3);
  559. void kvm_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4);
  560. void kvm_set_cr8(struct kvm_vcpu *vcpu, unsigned long cr8);
  561. unsigned long kvm_get_cr8(struct kvm_vcpu *vcpu);
  562. void kvm_lmsw(struct kvm_vcpu *vcpu, unsigned long msw);
  563. void kvm_get_cs_db_l_bits(struct kvm_vcpu *vcpu, int *db, int *l);
  564.  
  565. int kvm_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata);
  566. int kvm_set_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 data);
  567.  
  568. void kvm_queue_exception(struct kvm_vcpu *vcpu, unsigned nr);
  569. void kvm_queue_exception_e(struct kvm_vcpu *vcpu, unsigned nr, u32 error_code);
  570. void kvm_inject_page_fault(struct kvm_vcpu *vcpu, unsigned long cr2,
  571.                u32 error_code);
  572.  
  573. void kvm_pic_set_irq(void *opaque, int irq, int level);
  574.  
  575. void kvm_inject_nmi(struct kvm_vcpu *vcpu);
  576.  
  577. void fx_init(struct kvm_vcpu *vcpu);
  578.  
  579. int emulator_read_std(unsigned long addr,
  580.               void *val,
  581.               unsigned int bytes,
  582.               struct kvm_vcpu *vcpu);
  583. int emulator_write_emulated(unsigned long addr,
  584.                 const void *val,
  585.                 unsigned int bytes,
  586.                 struct kvm_vcpu *vcpu);
  587.  
  588. unsigned long segment_base(u16 selector);
  589.  
  590. void kvm_mmu_flush_tlb(struct kvm_vcpu *vcpu);
  591. void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa,
  592.                const u8 *new, int bytes);
  593. int kvm_mmu_unprotect_page_virt(struct kvm_vcpu *vcpu, gva_t gva);
  594. void __kvm_mmu_free_some_pages(struct kvm_vcpu *vcpu);
  595. int kvm_mmu_load(struct kvm_vcpu *vcpu);
  596. void kvm_mmu_unload(struct kvm_vcpu *vcpu);
  597. void kvm_mmu_sync_roots(struct kvm_vcpu *vcpu);
  598.  
  599. int kvm_emulate_hypercall(struct kvm_vcpu *vcpu);
  600.  
  601. int kvm_fix_hypercall(struct kvm_vcpu *vcpu);
  602.  
  603. int kvm_mmu_page_fault(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code);
  604. void kvm_mmu_invlpg(struct kvm_vcpu *vcpu, gva_t gva);
  605.  
  606. void kvm_enable_tdp(void);
  607. void kvm_disable_tdp(void);
  608.  
  609. int load_pdptrs(struct kvm_vcpu *vcpu, unsigned long cr3);
  610. int complete_pio(struct kvm_vcpu *vcpu);
  611.  
  612. struct kvm_memory_slot *gfn_to_memslot_unaliased(struct kvm *kvm, gfn_t gfn);
  613.  
  614. static inline struct kvm_mmu_page *page_header(hpa_t shadow_page)
  615. {
  616.     struct page *page = pfn_to_page(shadow_page >> PAGE_SHIFT);
  617.  
  618.     return (struct kvm_mmu_page *)page_private(page);
  619. }
  620.  
  621. static inline u16 kvm_read_fs(void)
  622. {
  623.     u16 seg;
  624.     asm("mov %%fs, %0" : "=g"(seg));
  625.     return seg;
  626. }
  627.  
  628. static inline u16 kvm_read_gs(void)
  629. {
  630.     u16 seg;
  631.     asm("mov %%gs, %0" : "=g"(seg));
  632.     return seg;
  633. }
  634.  
  635. static inline u16 kvm_read_ldt(void)
  636. {
  637.     u16 ldt;
  638.     asm("sldt %0" : "=g"(ldt));
  639.     return ldt;
  640. }
  641.  
  642. static inline void kvm_load_fs(u16 sel)
  643. {
  644.     asm("mov %0, %%fs" : : "rm"(sel));
  645. }
  646.  
  647. static inline void kvm_load_gs(u16 sel)
  648. {
  649.     asm("mov %0, %%gs" : : "rm"(sel));
  650. }
  651.  
  652. static inline void kvm_load_ldt(u16 sel)
  653. {
  654.     asm("lldt %0" : : "rm"(sel));
  655. }
  656.  
  657. static inline void kvm_get_idt(struct descriptor_table *table)
  658. {
  659.     asm("sidt %0" : "=m"(*table));
  660. }
  661.  
  662. static inline void kvm_get_gdt(struct descriptor_table *table)
  663. {
  664.     asm("sgdt %0" : "=m"(*table));
  665. }
  666.  
  667. static inline unsigned long kvm_read_tr_base(void)
  668. {
  669.     u16 tr;
  670.     asm("str %0" : "=g"(tr));
  671.     return segment_base(tr);
  672. }
  673.  
  674. #ifdef CONFIG_X86_64
  675. static inline unsigned long read_msr(unsigned long msr)
  676. {
  677.     u64 value;
  678.  
  679.     rdmsrl(msr, value);
  680.     return value;
  681. }
  682. #endif
  683.  
  684. static inline void kvm_fx_save(struct i387_fxsave_struct *image)
  685. {
  686.     asm("fxsave (%0)":: "r" (image));
  687. }
  688.  
  689. static inline void kvm_fx_restore(struct i387_fxsave_struct *image)
  690. {
  691.     asm("fxrstor (%0)":: "r" (image));
  692. }
  693.  
  694. static inline void kvm_fx_finit(void)
  695. {
  696.     asm("finit");
  697. }
  698.  
  699. static inline u32 get_rdx_init_val(void)
  700. {
  701.     return 0x600; /* P6 family */
  702. }
  703.  
  704. static inline void kvm_inject_gp(struct kvm_vcpu *vcpu, u32 error_code)
  705. {
  706.     kvm_queue_exception_e(vcpu, GP_VECTOR, error_code);
  707. }
  708.  
  709. #define ASM_VMX_VMCLEAR_RAX       ".byte 0x66, 0x0f, 0xc7, 0x30"
  710. #define ASM_VMX_VMLAUNCH          ".byte 0x0f, 0x01, 0xc2"
  711. #define ASM_VMX_VMRESUME          ".byte 0x0f, 0x01, 0xc3"
  712. #define ASM_VMX_VMPTRLD_RAX       ".byte 0x0f, 0xc7, 0x30"
  713. #define ASM_VMX_VMREAD_RDX_RAX    ".byte 0x0f, 0x78, 0xd0"
  714. #define ASM_VMX_VMWRITE_RAX_RDX   ".byte 0x0f, 0x79, 0xd0"
  715. #define ASM_VMX_VMWRITE_RSP_RDX   ".byte 0x0f, 0x79, 0xd4"
  716. #define ASM_VMX_VMXOFF            ".byte 0x0f, 0x01, 0xc4"
  717. #define ASM_VMX_VMXON_RAX         ".byte 0xf3, 0x0f, 0xc7, 0x30"
  718. #define ASM_VMX_INVEPT          ".byte 0x66, 0x0f, 0x38, 0x80, 0x08"
  719. #define ASM_VMX_INVVPID          ".byte 0x66, 0x0f, 0x38, 0x81, 0x08"
  720.  
  721. #define MSR_IA32_TIME_STAMP_COUNTER        0x010
  722.  
  723. #define TSS_IOPB_BASE_OFFSET 0x66
  724. #define TSS_BASE_SIZE 0x68
  725. #define TSS_IOPB_SIZE (65536 / 8)
  726. #define TSS_REDIRECTION_SIZE (256 / 8)
  727. #define RMODE_TSS_SIZE                            \
  728.     (TSS_BASE_SIZE + TSS_REDIRECTION_SIZE + TSS_IOPB_SIZE + 1)
  729.  
  730. enum {
  731.     TASK_SWITCH_CALL = 0,
  732.     TASK_SWITCH_IRET = 1,
  733.     TASK_SWITCH_JMP = 2,
  734.     TASK_SWITCH_GATE = 3,
  735. };
  736.  
  737. /*
  738.  * Hardware virtualization extension instructions may fault if a
  739.  * reboot turns off virtualization while processes are running.
  740.  * Trap the fault and ignore the instruction if that happens.
  741.  */
  742. asmlinkage void kvm_handle_fault_on_reboot(void);
  743.  
  744. #define __kvm_handle_fault_on_reboot(insn) \
  745.     "666: " insn "\n\t" \
  746.     ".pushsection .fixup, \"ax\" \n" \
  747.     "667: \n\t" \
  748.     __ASM_SIZE(push) " $666b \n\t"          \
  749.     "jmp kvm_handle_fault_on_reboot \n\t" \
  750.     ".popsection \n\t" \
  751.     ".pushsection __ex_table, \"a\" \n\t" \
  752.     _ASM_PTR " 666b, 667b \n\t" \
  753.     ".popsection"
  754.  
  755. #define KVM_ARCH_WANT_MMU_NOTIFIER
  756. int kvm_unmap_hva(struct kvm *kvm, unsigned long hva);
  757. int kvm_age_hva(struct kvm *kvm, unsigned long hva);
  758.  
  759. #endif /* _ASM_X86_KVM_HOST_H */
  760.