Avi Kivity | 26eef70 | 2008-07-03 14:59:22 +0300 | [diff] [blame] | 1 | #ifndef ARCH_X86_KVM_X86_H |
| 2 | #define ARCH_X86_KVM_X86_H |
| 3 | |
| 4 | #include <linux/kvm_host.h> |
Avi Kivity | 3eeb328 | 2010-01-21 15:31:48 +0200 | [diff] [blame] | 5 | #include "kvm_cache_regs.h" |
Avi Kivity | 26eef70 | 2008-07-03 14:59:22 +0300 | [diff] [blame] | 6 | |
Radim Krčmář | 7454570 | 2015-04-27 15:11:25 +0200 | [diff] [blame] | 7 | #define MSR_IA32_CR_PAT_DEFAULT 0x0007040600070406ULL |
| 8 | |
Avi Kivity | 26eef70 | 2008-07-03 14:59:22 +0300 | [diff] [blame] | 9 | static inline void kvm_clear_exception_queue(struct kvm_vcpu *vcpu) |
| 10 | { |
| 11 | vcpu->arch.exception.pending = false; |
| 12 | } |
| 13 | |
Gleb Natapov | 66fd3f7 | 2009-05-11 13:35:50 +0300 | [diff] [blame] | 14 | static inline void kvm_queue_interrupt(struct kvm_vcpu *vcpu, u8 vector, |
| 15 | bool soft) |
Avi Kivity | 937a7ea | 2008-07-03 15:17:01 +0300 | [diff] [blame] | 16 | { |
| 17 | vcpu->arch.interrupt.pending = true; |
Gleb Natapov | 66fd3f7 | 2009-05-11 13:35:50 +0300 | [diff] [blame] | 18 | vcpu->arch.interrupt.soft = soft; |
Avi Kivity | 937a7ea | 2008-07-03 15:17:01 +0300 | [diff] [blame] | 19 | vcpu->arch.interrupt.nr = vector; |
| 20 | } |
| 21 | |
| 22 | static inline void kvm_clear_interrupt_queue(struct kvm_vcpu *vcpu) |
| 23 | { |
| 24 | vcpu->arch.interrupt.pending = false; |
| 25 | } |
| 26 | |
Gleb Natapov | 3298b75 | 2009-05-11 13:35:46 +0300 | [diff] [blame] | 27 | static inline bool kvm_event_needs_reinjection(struct kvm_vcpu *vcpu) |
| 28 | { |
| 29 | return vcpu->arch.exception.pending || vcpu->arch.interrupt.pending || |
| 30 | vcpu->arch.nmi_injected; |
| 31 | } |
Gleb Natapov | 66fd3f7 | 2009-05-11 13:35:50 +0300 | [diff] [blame] | 32 | |
| 33 | static inline bool kvm_exception_is_soft(unsigned int nr) |
| 34 | { |
| 35 | return (nr == BP_VECTOR) || (nr == OF_VECTOR); |
| 36 | } |
Gleb Natapov | fc61b80 | 2009-07-05 17:39:35 +0300 | [diff] [blame] | 37 | |
Avi Kivity | 3eeb328 | 2010-01-21 15:31:48 +0200 | [diff] [blame] | 38 | static inline bool is_protmode(struct kvm_vcpu *vcpu) |
| 39 | { |
| 40 | return kvm_read_cr0_bits(vcpu, X86_CR0_PE); |
| 41 | } |
| 42 | |
Avi Kivity | 836a1b3 | 2010-01-21 15:31:49 +0200 | [diff] [blame] | 43 | static inline int is_long_mode(struct kvm_vcpu *vcpu) |
| 44 | { |
| 45 | #ifdef CONFIG_X86_64 |
Avi Kivity | f6801df | 2010-01-21 15:31:50 +0200 | [diff] [blame] | 46 | return vcpu->arch.efer & EFER_LMA; |
Avi Kivity | 836a1b3 | 2010-01-21 15:31:49 +0200 | [diff] [blame] | 47 | #else |
| 48 | return 0; |
| 49 | #endif |
| 50 | } |
| 51 | |
Nadav Amit | 5777392 | 2014-06-18 17:19:23 +0300 | [diff] [blame] | 52 | static inline bool is_64_bit_mode(struct kvm_vcpu *vcpu) |
| 53 | { |
| 54 | int cs_db, cs_l; |
| 55 | |
| 56 | if (!is_long_mode(vcpu)) |
| 57 | return false; |
| 58 | kvm_x86_ops->get_cs_db_l_bits(vcpu, &cs_db, &cs_l); |
| 59 | return cs_l; |
| 60 | } |
| 61 | |
Joerg Roedel | 6539e73 | 2010-09-10 17:30:50 +0200 | [diff] [blame] | 62 | static inline bool mmu_is_nested(struct kvm_vcpu *vcpu) |
| 63 | { |
| 64 | return vcpu->arch.walk_mmu == &vcpu->arch.nested_mmu; |
| 65 | } |
| 66 | |
Avi Kivity | 836a1b3 | 2010-01-21 15:31:49 +0200 | [diff] [blame] | 67 | static inline int is_pae(struct kvm_vcpu *vcpu) |
| 68 | { |
| 69 | return kvm_read_cr4_bits(vcpu, X86_CR4_PAE); |
| 70 | } |
| 71 | |
| 72 | static inline int is_pse(struct kvm_vcpu *vcpu) |
| 73 | { |
| 74 | return kvm_read_cr4_bits(vcpu, X86_CR4_PSE); |
| 75 | } |
| 76 | |
| 77 | static inline int is_paging(struct kvm_vcpu *vcpu) |
| 78 | { |
Davidlohr Bueso | c36fc04 | 2012-03-08 12:45:54 +0100 | [diff] [blame] | 79 | return likely(kvm_read_cr0_bits(vcpu, X86_CR0_PG)); |
Avi Kivity | 836a1b3 | 2010-01-21 15:31:49 +0200 | [diff] [blame] | 80 | } |
| 81 | |
Joerg Roedel | 24d1b15 | 2010-12-07 17:15:05 +0100 | [diff] [blame] | 82 | static inline u32 bit(int bitno) |
| 83 | { |
| 84 | return 1 << (bitno & 31); |
| 85 | } |
| 86 | |
Xiao Guangrong | bebb106 | 2011-07-12 03:23:20 +0800 | [diff] [blame] | 87 | static inline void vcpu_cache_mmio_info(struct kvm_vcpu *vcpu, |
| 88 | gva_t gva, gfn_t gfn, unsigned access) |
| 89 | { |
| 90 | vcpu->arch.mmio_gva = gva & PAGE_MASK; |
| 91 | vcpu->arch.access = access; |
| 92 | vcpu->arch.mmio_gfn = gfn; |
David Matlack | 56f17dd | 2014-08-18 15:46:07 -0700 | [diff] [blame] | 93 | vcpu->arch.mmio_gen = kvm_memslots(vcpu->kvm)->generation; |
| 94 | } |
| 95 | |
| 96 | static inline bool vcpu_match_mmio_gen(struct kvm_vcpu *vcpu) |
| 97 | { |
| 98 | return vcpu->arch.mmio_gen == kvm_memslots(vcpu->kvm)->generation; |
Xiao Guangrong | bebb106 | 2011-07-12 03:23:20 +0800 | [diff] [blame] | 99 | } |
| 100 | |
| 101 | /* |
David Matlack | 56f17dd | 2014-08-18 15:46:07 -0700 | [diff] [blame] | 102 | * Clear the mmio cache info for the given gva. If gva is MMIO_GVA_ANY, we |
| 103 | * clear all mmio cache info. |
Xiao Guangrong | bebb106 | 2011-07-12 03:23:20 +0800 | [diff] [blame] | 104 | */ |
David Matlack | 56f17dd | 2014-08-18 15:46:07 -0700 | [diff] [blame] | 105 | #define MMIO_GVA_ANY (~(gva_t)0) |
| 106 | |
Xiao Guangrong | bebb106 | 2011-07-12 03:23:20 +0800 | [diff] [blame] | 107 | static inline void vcpu_clear_mmio_info(struct kvm_vcpu *vcpu, gva_t gva) |
| 108 | { |
David Matlack | 56f17dd | 2014-08-18 15:46:07 -0700 | [diff] [blame] | 109 | if (gva != MMIO_GVA_ANY && vcpu->arch.mmio_gva != (gva & PAGE_MASK)) |
Xiao Guangrong | bebb106 | 2011-07-12 03:23:20 +0800 | [diff] [blame] | 110 | return; |
| 111 | |
| 112 | vcpu->arch.mmio_gva = 0; |
| 113 | } |
| 114 | |
| 115 | static inline bool vcpu_match_mmio_gva(struct kvm_vcpu *vcpu, unsigned long gva) |
| 116 | { |
David Matlack | 56f17dd | 2014-08-18 15:46:07 -0700 | [diff] [blame] | 117 | if (vcpu_match_mmio_gen(vcpu) && vcpu->arch.mmio_gva && |
| 118 | vcpu->arch.mmio_gva == (gva & PAGE_MASK)) |
Xiao Guangrong | bebb106 | 2011-07-12 03:23:20 +0800 | [diff] [blame] | 119 | return true; |
| 120 | |
| 121 | return false; |
| 122 | } |
| 123 | |
| 124 | static inline bool vcpu_match_mmio_gpa(struct kvm_vcpu *vcpu, gpa_t gpa) |
| 125 | { |
David Matlack | 56f17dd | 2014-08-18 15:46:07 -0700 | [diff] [blame] | 126 | if (vcpu_match_mmio_gen(vcpu) && vcpu->arch.mmio_gfn && |
| 127 | vcpu->arch.mmio_gfn == gpa >> PAGE_SHIFT) |
Xiao Guangrong | bebb106 | 2011-07-12 03:23:20 +0800 | [diff] [blame] | 128 | return true; |
| 129 | |
| 130 | return false; |
| 131 | } |
| 132 | |
Nadav Amit | 5777392 | 2014-06-18 17:19:23 +0300 | [diff] [blame] | 133 | static inline unsigned long kvm_register_readl(struct kvm_vcpu *vcpu, |
| 134 | enum kvm_reg reg) |
| 135 | { |
| 136 | unsigned long val = kvm_register_read(vcpu, reg); |
| 137 | |
| 138 | return is_64_bit_mode(vcpu) ? val : (u32)val; |
| 139 | } |
| 140 | |
Nadav Amit | 27e6fb5 | 2014-06-18 17:19:26 +0300 | [diff] [blame] | 141 | static inline void kvm_register_writel(struct kvm_vcpu *vcpu, |
| 142 | enum kvm_reg reg, |
| 143 | unsigned long val) |
| 144 | { |
| 145 | if (!is_64_bit_mode(vcpu)) |
| 146 | val = (u32)val; |
| 147 | return kvm_register_write(vcpu, reg, val); |
| 148 | } |
| 149 | |
Andrey Smetanin | e83d588 | 2015-07-03 15:01:34 +0300 | [diff] [blame] | 150 | static inline u64 get_kernel_ns(void) |
| 151 | { |
| 152 | return ktime_get_boot_ns(); |
| 153 | } |
| 154 | |
Paolo Bonzini | 41dbc6b | 2015-07-23 08:22:45 +0200 | [diff] [blame] | 155 | static inline bool kvm_check_has_quirk(struct kvm *kvm, u64 quirk) |
| 156 | { |
| 157 | return !(kvm->arch.disabled_quirks & quirk); |
| 158 | } |
| 159 | |
Zhang, Yanmin | ff9d07a | 2010-04-19 13:32:45 +0800 | [diff] [blame] | 160 | void kvm_before_handle_nmi(struct kvm_vcpu *vcpu); |
| 161 | void kvm_after_handle_nmi(struct kvm_vcpu *vcpu); |
Nicholas Krause | bab5bb3 | 2015-01-01 22:05:18 -0500 | [diff] [blame] | 162 | void kvm_set_pending_timer(struct kvm_vcpu *vcpu); |
Serge E. Hallyn | 71f9833 | 2011-04-13 09:12:54 -0500 | [diff] [blame] | 163 | int kvm_inject_realmode_interrupt(struct kvm_vcpu *vcpu, int irq, int inc_eip); |
Zhang, Yanmin | ff9d07a | 2010-04-19 13:32:45 +0800 | [diff] [blame] | 164 | |
Will Auld | 8fe8ab4 | 2012-11-29 12:42:12 -0800 | [diff] [blame] | 165 | void kvm_write_tsc(struct kvm_vcpu *vcpu, struct msr_data *msr); |
Zachary Amsden | 99e3e30 | 2010-08-19 22:07:17 -1000 | [diff] [blame] | 166 | |
Nadav Har'El | 064aea7 | 2011-05-25 23:04:56 +0300 | [diff] [blame] | 167 | int kvm_read_guest_virt(struct x86_emulate_ctxt *ctxt, |
| 168 | gva_t addr, void *val, unsigned int bytes, |
| 169 | struct x86_exception *exception); |
| 170 | |
Nadav Har'El | 6a4d755 | 2011-05-25 23:08:00 +0300 | [diff] [blame] | 171 | int kvm_write_guest_virt_system(struct x86_emulate_ctxt *ctxt, |
| 172 | gva_t addr, void *val, unsigned int bytes, |
| 173 | struct x86_exception *exception); |
| 174 | |
Xiao Guangrong | 19efffa | 2015-06-15 16:55:31 +0800 | [diff] [blame] | 175 | void kvm_vcpu_mtrr_init(struct kvm_vcpu *vcpu); |
Xiao Guangrong | ff53604 | 2015-06-15 16:55:22 +0800 | [diff] [blame] | 176 | u8 kvm_mtrr_get_guest_memory_type(struct kvm_vcpu *vcpu, gfn_t gfn); |
Nadav Amit | 4566654 | 2014-09-18 22:39:44 +0300 | [diff] [blame] | 177 | bool kvm_mtrr_valid(struct kvm_vcpu *vcpu, u32 msr, u64 data); |
Xiao Guangrong | ff53604 | 2015-06-15 16:55:22 +0800 | [diff] [blame] | 178 | int kvm_mtrr_set_msr(struct kvm_vcpu *vcpu, u32 msr, u64 data); |
| 179 | int kvm_mtrr_get_msr(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata); |
Xiao Guangrong | 6a39bbc | 2015-06-15 16:55:35 +0800 | [diff] [blame] | 180 | bool kvm_mtrr_check_gfn_range_consistency(struct kvm_vcpu *vcpu, gfn_t gfn, |
| 181 | int page_num); |
Feng Wu | 52004014 | 2016-01-25 16:53:33 +0800 | [diff] [blame] | 182 | bool kvm_vector_hashing_enabled(void); |
Nadav Amit | 4566654 | 2014-09-18 22:39:44 +0300 | [diff] [blame] | 183 | |
Dave Hansen | d91cab7 | 2015-09-02 16:31:26 -0700 | [diff] [blame] | 184 | #define KVM_SUPPORTED_XCR0 (XFEATURE_MASK_FP | XFEATURE_MASK_SSE \ |
| 185 | | XFEATURE_MASK_YMM | XFEATURE_MASK_BNDREGS \ |
Huaitong Han | 17a511f | 2016-03-22 16:51:16 +0800 | [diff] [blame] | 186 | | XFEATURE_MASK_BNDCSR | XFEATURE_MASK_AVX512 \ |
| 187 | | XFEATURE_MASK_PKRU) |
Avi Kivity | 00b27a3 | 2011-11-23 16:30:32 +0200 | [diff] [blame] | 188 | extern u64 host_xcr0; |
| 189 | |
Paolo Bonzini | 4ff4173 | 2014-02-24 12:15:16 +0100 | [diff] [blame] | 190 | extern u64 kvm_supported_xcr0(void); |
| 191 | |
Marcelo Tosatti | 9ed96e8 | 2014-01-06 12:00:02 -0200 | [diff] [blame] | 192 | extern unsigned int min_timer_period_us; |
| 193 | |
Marcelo Tosatti | d0659d9 | 2014-12-16 09:08:15 -0500 | [diff] [blame] | 194 | extern unsigned int lapic_timer_advance_ns; |
| 195 | |
Gleb Natapov | 54e9818 | 2012-08-05 15:58:32 +0300 | [diff] [blame] | 196 | extern struct static_key kvm_no_apic_vcpu; |
Paolo Bonzini | b51012d | 2016-01-22 11:39:22 +0100 | [diff] [blame] | 197 | |
| 198 | /* Same "calling convention" as do_div: |
| 199 | * - divide (n << 32) by base |
| 200 | * - put result in n |
| 201 | * - return remainder |
| 202 | */ |
| 203 | #define do_shl32_div32(n, base) \ |
| 204 | ({ \ |
| 205 | u32 __quot, __rem; \ |
| 206 | asm("divl %2" : "=a" (__quot), "=d" (__rem) \ |
| 207 | : "rm" (base), "0" (0), "1" ((u32) n)); \ |
| 208 | n = __quot; \ |
| 209 | __rem; \ |
| 210 | }) |
| 211 | |
Avi Kivity | 26eef70 | 2008-07-03 14:59:22 +0300 | [diff] [blame] | 212 | #endif |