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 unsigned long slot_bitmap; /* One bit set per slot which has memory 194 * in this shadow page. 195 */ 196 int multimapped; /* More than one parent_pte? */ 197 int root_count; /* Currently serving as active root */ 198 bool unsync; 199 bool unsync_children; 200 union { 201 u64 *parent_pte; /* !multimapped */ 202 struct hlist_head parent_ptes; /* multimapped, kvm_pte_chain */ 203 }; 204 DECLARE_BITMAP(unsync_child_bitmap, 512); 205 }; 206 207 struct kvm_pv_mmu_op_buffer { 208 void *ptr; 209 unsigned len; 210 unsigned processed; 211 char buf[512] __aligned(sizeof(long)); 212 }; 213 214 /* 215 * x86 supports 3 paging modes (4-level 64-bit, 3-level 64-bit, and 2-level 216 * 32-bit). The kvm_mmu structure abstracts the details of the current mmu 217 * mode. 218 */ 219 struct kvm_mmu { 220 void (*new_cr3)(struct kvm_vcpu *vcpu); 221 int (*page_fault)(struct kvm_vcpu *vcpu, gva_t gva, u32 err); 222 void (*free)(struct kvm_vcpu *vcpu); 223 gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva); 224 void (*prefetch_page)(struct kvm_vcpu *vcpu, 225 struct kvm_mmu_page *page); 226 int (*sync_page)(struct kvm_vcpu *vcpu, 227 struct kvm_mmu_page *sp); 228 void (*invlpg)(struct kvm_vcpu *vcpu, gva_t gva); 229 hpa_t root_hpa; 230 int root_level; 231 int shadow_root_level; 232 233 u64 *pae_root; 234 }; 235 236 struct kvm_vcpu_arch { 237 u64 host_tsc; 238 int interrupt_window_open; 239 unsigned long irq_summary; /* bit vector: 1 per word in irq_pending */ 240 DECLARE_BITMAP(irq_pending, KVM_NR_INTERRUPTS); 241 /* 242 * rip and regs accesses must go through 243 * kvm_{register,rip}_{read,write} functions. 244 */ 245 unsigned long regs[NR_VCPU_REGS]; 246 u32 regs_avail; 247 u32 regs_dirty; 248 249 unsigned long cr0; 250 unsigned long cr2; 251 unsigned long cr3; 252 unsigned long cr4; 253 unsigned long cr8; 254 u64 pdptrs[4]; /* pae */ 255 u64 shadow_efer; 256 u64 apic_base; 257 struct kvm_lapic *apic; /* kernel irqchip context */ 258 int mp_state; 259 int sipi_vector; 260 u64 ia32_misc_enable_msr; 261 bool tpr_access_reporting; 262 263 struct kvm_mmu mmu; 264 /* only needed in kvm_pv_mmu_op() path, but it's hot so 265 * put it here to avoid allocation */ 266 struct kvm_pv_mmu_op_buffer mmu_op_buffer; 267 268 struct kvm_mmu_memory_cache mmu_pte_chain_cache; 269 struct kvm_mmu_memory_cache mmu_rmap_desc_cache; 270 struct kvm_mmu_memory_cache mmu_page_cache; 271 struct kvm_mmu_memory_cache mmu_page_header_cache; 272 273 gfn_t last_pt_write_gfn; 274 int last_pt_write_count; 275 u64 *last_pte_updated; 276 gfn_t last_pte_gfn; 277 278 struct { 279 gfn_t gfn; /* presumed gfn during guest pte update */ 280 pfn_t pfn; /* pfn corresponding to that gfn */ 281 int largepage; 282 unsigned long mmu_seq; 283 } update_pte; 284 285 struct i387_fxsave_struct host_fx_image; 286 struct i387_fxsave_struct guest_fx_image; 287 288 gva_t mmio_fault_cr2; 289 struct kvm_pio_request pio; 290 void *pio_data; 291 292 struct kvm_queued_exception { 293 bool pending; 294 bool has_error_code; 295 u8 nr; 296 u32 error_code; 297 } exception; 298 299 struct kvm_queued_interrupt { 300 bool pending; 301 u8 nr; 302 } interrupt; 303 304 struct { 305 int active; 306 u8 save_iopl; 307 struct kvm_save_segment { 308 u16 selector; 309 unsigned long base; 310 u32 limit; 311 u32 ar; 312 } tr, es, ds, fs, gs; 313 } rmode; 314 int halt_request; /* real mode on Intel only */ 315 316 int cpuid_nent; 317 struct kvm_cpuid_entry2 cpuid_entries[KVM_MAX_CPUID_ENTRIES]; 318 /* emulate context */ 319 320 struct x86_emulate_ctxt emulate_ctxt; 321 322 gpa_t time; 323 struct pvclock_vcpu_time_info hv_clock; 324 unsigned int hv_clock_tsc_khz; 325 unsigned int time_offset; 326 struct page *time_page; 327 328 bool nmi_pending; 329 bool nmi_injected; 330 331 u64 mtrr[0x100]; 332 }; 333 334 struct kvm_mem_alias { 335 gfn_t base_gfn; 336 unsigned long npages; 337 gfn_t target_gfn; 338 }; 339 340 struct kvm_arch{ 341 int naliases; 342 struct kvm_mem_alias aliases[KVM_ALIAS_SLOTS]; 343 344 unsigned int n_free_mmu_pages; 345 unsigned int n_requested_mmu_pages; 346 unsigned int n_alloc_mmu_pages; 347 struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES]; 348 /* 349 * Hash table of struct kvm_mmu_page. 350 */ 351 struct list_head active_mmu_pages; 352 struct list_head assigned_dev_head; 353 struct dmar_domain *intel_iommu_domain; 354 struct kvm_pic *vpic; 355 struct kvm_ioapic *vioapic; 356 struct kvm_pit *vpit; 357 struct hlist_head irq_ack_notifier_list; 358 359 int round_robin_prev_vcpu; 360 unsigned int tss_addr; 361 struct page *apic_access_page; 362 363 gpa_t wall_clock; 364 365 struct page *ept_identity_pagetable; 366 bool ept_identity_pagetable_done; 367 368 unsigned long irq_sources_bitmap; 369 unsigned long irq_states[KVM_IOAPIC_NUM_PINS]; 370 }; 371 372 struct kvm_vm_stat { 373 u32 mmu_shadow_zapped; 374 u32 mmu_pte_write; 375 u32 mmu_pte_updated; 376 u32 mmu_pde_zapped; 377 u32 mmu_flooded; 378 u32 mmu_recycled; 379 u32 mmu_cache_miss; 380 u32 mmu_unsync; 381 u32 remote_tlb_flush; 382 u32 lpages; 383 }; 384 385 struct kvm_vcpu_stat { 386 u32 pf_fixed; 387 u32 pf_guest; 388 u32 tlb_flush; 389 u32 invlpg; 390 391 u32 exits; 392 u32 io_exits; 393 u32 mmio_exits; 394 u32 signal_exits; 395 u32 irq_window_exits; 396 u32 nmi_window_exits; 397 u32 halt_exits; 398 u32 halt_wakeup; 399 u32 request_irq_exits; 400 u32 irq_exits; 401 u32 host_state_reload; 402 u32 efer_reload; 403 u32 fpu_reload; 404 u32 insn_emulation; 405 u32 insn_emulation_fail; 406 u32 hypercalls; 407 u32 irq_injections; 408 }; 409 410 struct descriptor_table { 411 u16 limit; 412 unsigned long base; 413 } __attribute__((packed)); 414 415 struct kvm_x86_ops { 416 int (*cpu_has_kvm_support)(void); /* __init */ 417 int (*disabled_by_bios)(void); /* __init */ 418 void (*hardware_enable)(void *dummy); /* __init */ 419 void (*hardware_disable)(void *dummy); 420 void (*check_processor_compatibility)(void *rtn); 421 int (*hardware_setup)(void); /* __init */ 422 void (*hardware_unsetup)(void); /* __exit */ 423 bool (*cpu_has_accelerated_tpr)(void); 424 425 /* Create, but do not attach this VCPU */ 426 struct kvm_vcpu *(*vcpu_create)(struct kvm *kvm, unsigned id); 427 void (*vcpu_free)(struct kvm_vcpu *vcpu); 428 int (*vcpu_reset)(struct kvm_vcpu *vcpu); 429 430 void (*prepare_guest_switch)(struct kvm_vcpu *vcpu); 431 void (*vcpu_load)(struct kvm_vcpu *vcpu, int cpu); 432 void (*vcpu_put)(struct kvm_vcpu *vcpu); 433 434 int (*set_guest_debug)(struct kvm_vcpu *vcpu, 435 struct kvm_debug_guest *dbg); 436 void (*guest_debug_pre)(struct kvm_vcpu *vcpu); 437 int (*get_msr)(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata); 438 int (*set_msr)(struct kvm_vcpu *vcpu, u32 msr_index, u64 data); 439 u64 (*get_segment_base)(struct kvm_vcpu *vcpu, int seg); 440 void (*get_segment)(struct kvm_vcpu *vcpu, 441 struct kvm_segment *var, int seg); 442 int (*get_cpl)(struct kvm_vcpu *vcpu); 443 void (*set_segment)(struct kvm_vcpu *vcpu, 444 struct kvm_segment *var, int seg); 445 void (*get_cs_db_l_bits)(struct kvm_vcpu *vcpu, int *db, int *l); 446 void (*decache_cr4_guest_bits)(struct kvm_vcpu *vcpu); 447 void (*set_cr0)(struct kvm_vcpu *vcpu, unsigned long cr0); 448 void (*set_cr3)(struct kvm_vcpu *vcpu, unsigned long cr3); 449 void (*set_cr4)(struct kvm_vcpu *vcpu, unsigned long cr4); 450 void (*set_efer)(struct kvm_vcpu *vcpu, u64 efer); 451 void (*get_idt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt); 452 void (*set_idt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt); 453 void (*get_gdt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt); 454 void (*set_gdt)(struct kvm_vcpu *vcpu, struct descriptor_table *dt); 455 unsigned long (*get_dr)(struct kvm_vcpu *vcpu, int dr); 456 void (*set_dr)(struct kvm_vcpu *vcpu, int dr, unsigned long value, 457 int *exception); 458 void (*cache_reg)(struct kvm_vcpu *vcpu, enum kvm_reg reg); 459 unsigned long (*get_rflags)(struct kvm_vcpu *vcpu); 460 void (*set_rflags)(struct kvm_vcpu *vcpu, unsigned long rflags); 461 462 void (*tlb_flush)(struct kvm_vcpu *vcpu); 463 464 void (*run)(struct kvm_vcpu *vcpu, struct kvm_run *run); 465 int (*handle_exit)(struct kvm_run *run, struct kvm_vcpu *vcpu); 466 void (*skip_emulated_instruction)(struct kvm_vcpu *vcpu); 467 void (*patch_hypercall)(struct kvm_vcpu *vcpu, 468 unsigned char *hypercall_addr); 469 int (*get_irq)(struct kvm_vcpu *vcpu); 470 void (*set_irq)(struct kvm_vcpu *vcpu, int vec); 471 void (*queue_exception)(struct kvm_vcpu *vcpu, unsigned nr, 472 bool has_error_code, u32 error_code); 473 bool (*exception_injected)(struct kvm_vcpu *vcpu); 474 void (*inject_pending_irq)(struct kvm_vcpu *vcpu); 475 void (*inject_pending_vectors)(struct kvm_vcpu *vcpu, 476 struct kvm_run *run); 477 478 int (*set_tss_addr)(struct kvm *kvm, unsigned int addr); 479 int (*get_tdp_level)(void); 480 }; 481 482 extern struct kvm_x86_ops *kvm_x86_ops; 483 484 int kvm_mmu_module_init(void); 485 void kvm_mmu_module_exit(void); 486 487 void kvm_mmu_destroy(struct kvm_vcpu *vcpu); 488 int kvm_mmu_create(struct kvm_vcpu *vcpu); 489 int kvm_mmu_setup(struct kvm_vcpu *vcpu); 490 void kvm_mmu_set_nonpresent_ptes(u64 trap_pte, u64 notrap_pte); 491 void kvm_mmu_set_base_ptes(u64 base_pte); 492 void kvm_mmu_set_mask_ptes(u64 user_mask, u64 accessed_mask, 493 u64 dirty_mask, u64 nx_mask, u64 x_mask); 494 495 int kvm_mmu_reset_context(struct kvm_vcpu *vcpu); 496 void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot); 497 void kvm_mmu_zap_all(struct kvm *kvm); 498 unsigned int kvm_mmu_calculate_mmu_pages(struct kvm *kvm); 499 void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int kvm_nr_mmu_pages); 500 501 int load_pdptrs(struct kvm_vcpu *vcpu, unsigned long cr3); 502 503 int emulator_write_phys(struct kvm_vcpu *vcpu, gpa_t gpa, 504 const void *val, int bytes); 505 int kvm_pv_mmu_op(struct kvm_vcpu *vcpu, unsigned long bytes, 506 gpa_t addr, unsigned long *ret); 507 508 extern bool tdp_enabled; 509 510 enum emulation_result { 511 EMULATE_DONE, /* no further processing */ 512 EMULATE_DO_MMIO, /* kvm_run filled with mmio request */ 513 EMULATE_FAIL, /* can't emulate this instruction */ 514 }; 515 516 #define EMULTYPE_NO_DECODE (1 << 0) 517 #define EMULTYPE_TRAP_UD (1 << 1) 518 int emulate_instruction(struct kvm_vcpu *vcpu, struct kvm_run *run, 519 unsigned long cr2, u16 error_code, int emulation_type); 520 void kvm_report_emulation_failure(struct kvm_vcpu *cvpu, const char *context); 521 void realmode_lgdt(struct kvm_vcpu *vcpu, u16 size, unsigned long address); 522 void realmode_lidt(struct kvm_vcpu *vcpu, u16 size, unsigned long address); 523 void realmode_lmsw(struct kvm_vcpu *vcpu, unsigned long msw, 524 unsigned long *rflags); 525 526 unsigned long realmode_get_cr(struct kvm_vcpu *vcpu, int cr); 527 void realmode_set_cr(struct kvm_vcpu *vcpu, int cr, unsigned long value, 528 unsigned long *rflags); 529 void kvm_enable_efer_bits(u64); 530 int kvm_get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *data); 531 int kvm_set_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data); 532 533 struct x86_emulate_ctxt; 534 535 int kvm_emulate_pio(struct kvm_vcpu *vcpu, struct kvm_run *run, int in, 536 int size, unsigned port); 537 int kvm_emulate_pio_string(struct kvm_vcpu *vcpu, struct kvm_run *run, int in, 538 int size, unsigned long count, int down, 539 gva_t address, int rep, unsigned port); 540 void kvm_emulate_cpuid(struct kvm_vcpu *vcpu); 541 int kvm_emulate_halt(struct kvm_vcpu *vcpu); 542 int emulate_invlpg(struct kvm_vcpu *vcpu, gva_t address); 543 int emulate_clts(struct kvm_vcpu *vcpu); 544 int emulator_get_dr(struct x86_emulate_ctxt *ctxt, int dr, 545 unsigned long *dest); 546 int emulator_set_dr(struct x86_emulate_ctxt *ctxt, int dr, 547 unsigned long value); 548 549 void kvm_get_segment(struct kvm_vcpu *vcpu, struct kvm_segment *var, int seg); 550 int kvm_load_segment_descriptor(struct kvm_vcpu *vcpu, u16 selector, 551 int type_bits, int seg); 552 553 int kvm_task_switch(struct kvm_vcpu *vcpu, u16 tss_selector, int reason); 554 555 void kvm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0); 556 void kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3); 557 void kvm_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4); 558 void kvm_set_cr8(struct kvm_vcpu *vcpu, unsigned long cr8); 559 unsigned long kvm_get_cr8(struct kvm_vcpu *vcpu); 560 void kvm_lmsw(struct kvm_vcpu *vcpu, unsigned long msw); 561 void kvm_get_cs_db_l_bits(struct kvm_vcpu *vcpu, int *db, int *l); 562 563 int kvm_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata); 564 int kvm_set_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 data); 565 566 void kvm_queue_exception(struct kvm_vcpu *vcpu, unsigned nr); 567 void kvm_queue_exception_e(struct kvm_vcpu *vcpu, unsigned nr, u32 error_code); 568 void kvm_inject_page_fault(struct kvm_vcpu *vcpu, unsigned long cr2, 569 u32 error_code); 570 571 void kvm_pic_set_irq(void *opaque, int irq, int level); 572 573 void kvm_inject_nmi(struct kvm_vcpu *vcpu); 574 575 void fx_init(struct kvm_vcpu *vcpu); 576 577 int emulator_read_std(unsigned long addr, 578 void *val, 579 unsigned int bytes, 580 struct kvm_vcpu *vcpu); 581 int emulator_write_emulated(unsigned long addr, 582 const void *val, 583 unsigned int bytes, 584 struct kvm_vcpu *vcpu); 585 586 unsigned long segment_base(u16 selector); 587 588 void kvm_mmu_flush_tlb(struct kvm_vcpu *vcpu); 589 void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa, 590 const u8 *new, int bytes); 591 int kvm_mmu_unprotect_page_virt(struct kvm_vcpu *vcpu, gva_t gva); 592 void __kvm_mmu_free_some_pages(struct kvm_vcpu *vcpu); 593 int kvm_mmu_load(struct kvm_vcpu *vcpu); 594 void kvm_mmu_unload(struct kvm_vcpu *vcpu); 595 void kvm_mmu_sync_roots(struct kvm_vcpu *vcpu); 596 597 int kvm_emulate_hypercall(struct kvm_vcpu *vcpu); 598 599 int kvm_fix_hypercall(struct kvm_vcpu *vcpu); 600 601 int kvm_mmu_page_fault(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code); 602 void kvm_mmu_invlpg(struct kvm_vcpu *vcpu, gva_t gva); 603 604 void kvm_enable_tdp(void); 605 void kvm_disable_tdp(void); 606 607 int load_pdptrs(struct kvm_vcpu *vcpu, unsigned long cr3); 608 int complete_pio(struct kvm_vcpu *vcpu); 609 610 static inline struct kvm_mmu_page *page_header(hpa_t shadow_page) 611 { 612 struct page *page = pfn_to_page(shadow_page >> PAGE_SHIFT); 613 614 return (struct kvm_mmu_page *)page_private(page); 615 } 616 617 static inline u16 kvm_read_fs(void) 618 { 619 u16 seg; 620 asm("mov %%fs, %0" : "=g"(seg)); 621 return seg; 622 } 623 624 static inline u16 kvm_read_gs(void) 625 { 626 u16 seg; 627 asm("mov %%gs, %0" : "=g"(seg)); 628 return seg; 629 } 630 631 static inline u16 kvm_read_ldt(void) 632 { 633 u16 ldt; 634 asm("sldt %0" : "=g"(ldt)); 635 return ldt; 636 } 637 638 static inline void kvm_load_fs(u16 sel) 639 { 640 asm("mov %0, %%fs" : : "rm"(sel)); 641 } 642 643 static inline void kvm_load_gs(u16 sel) 644 { 645 asm("mov %0, %%gs" : : "rm"(sel)); 646 } 647 648 static inline void kvm_load_ldt(u16 sel) 649 { 650 asm("lldt %0" : : "rm"(sel)); 651 } 652 653 static inline void kvm_get_idt(struct descriptor_table *table) 654 { 655 asm("sidt %0" : "=m"(*table)); 656 } 657 658 static inline void kvm_get_gdt(struct descriptor_table *table) 659 { 660 asm("sgdt %0" : "=m"(*table)); 661 } 662 663 static inline unsigned long kvm_read_tr_base(void) 664 { 665 u16 tr; 666 asm("str %0" : "=g"(tr)); 667 return segment_base(tr); 668 } 669 670 #ifdef CONFIG_X86_64 671 static inline unsigned long read_msr(unsigned long msr) 672 { 673 u64 value; 674 675 rdmsrl(msr, value); 676 return value; 677 } 678 #endif 679 680 static inline void kvm_fx_save(struct i387_fxsave_struct *image) 681 { 682 asm("fxsave (%0)":: "r" (image)); 683 } 684 685 static inline void kvm_fx_restore(struct i387_fxsave_struct *image) 686 { 687 asm("fxrstor (%0)":: "r" (image)); 688 } 689 690 static inline void kvm_fx_finit(void) 691 { 692 asm("finit"); 693 } 694 695 static inline u32 get_rdx_init_val(void) 696 { 697 return 0x600; /* P6 family */ 698 } 699 700 static inline void kvm_inject_gp(struct kvm_vcpu *vcpu, u32 error_code) 701 { 702 kvm_queue_exception_e(vcpu, GP_VECTOR, error_code); 703 } 704 705 #define ASM_VMX_VMCLEAR_RAX ".byte 0x66, 0x0f, 0xc7, 0x30" 706 #define ASM_VMX_VMLAUNCH ".byte 0x0f, 0x01, 0xc2" 707 #define ASM_VMX_VMRESUME ".byte 0x0f, 0x01, 0xc3" 708 #define ASM_VMX_VMPTRLD_RAX ".byte 0x0f, 0xc7, 0x30" 709 #define ASM_VMX_VMREAD_RDX_RAX ".byte 0x0f, 0x78, 0xd0" 710 #define ASM_VMX_VMWRITE_RAX_RDX ".byte 0x0f, 0x79, 0xd0" 711 #define ASM_VMX_VMWRITE_RSP_RDX ".byte 0x0f, 0x79, 0xd4" 712 #define ASM_VMX_VMXOFF ".byte 0x0f, 0x01, 0xc4" 713 #define ASM_VMX_VMXON_RAX ".byte 0xf3, 0x0f, 0xc7, 0x30" 714 #define ASM_VMX_INVEPT ".byte 0x66, 0x0f, 0x38, 0x80, 0x08" 715 #define ASM_VMX_INVVPID ".byte 0x66, 0x0f, 0x38, 0x81, 0x08" 716 717 #define MSR_IA32_TIME_STAMP_COUNTER 0x010 718 719 #define TSS_IOPB_BASE_OFFSET 0x66 720 #define TSS_BASE_SIZE 0x68 721 #define TSS_IOPB_SIZE (65536 / 8) 722 #define TSS_REDIRECTION_SIZE (256 / 8) 723 #define RMODE_TSS_SIZE \ 724 (TSS_BASE_SIZE + TSS_REDIRECTION_SIZE + TSS_IOPB_SIZE + 1) 725 726 enum { 727 TASK_SWITCH_CALL = 0, 728 TASK_SWITCH_IRET = 1, 729 TASK_SWITCH_JMP = 2, 730 TASK_SWITCH_GATE = 3, 731 }; 732 733 /* 734 * Hardware virtualization extension instructions may fault if a 735 * reboot turns off virtualization while processes are running. 736 * Trap the fault and ignore the instruction if that happens. 737 */ 738 asmlinkage void kvm_handle_fault_on_reboot(void); 739 740 #define __kvm_handle_fault_on_reboot(insn) \ 741 "666: " insn "\n\t" \ 742 ".pushsection .fixup, \"ax\" \n" \ 743 "667: \n\t" \ 744 __ASM_SIZE(push) " $666b \n\t" \ 745 "jmp kvm_handle_fault_on_reboot \n\t" \ 746 ".popsection \n\t" \ 747 ".pushsection __ex_table, \"a\" \n\t" \ 748 _ASM_PTR " 666b, 667b \n\t" \ 749 ".popsection" 750 751 #define KVM_ARCH_WANT_MMU_NOTIFIER 752 int kvm_unmap_hva(struct kvm *kvm, unsigned long hva); 753 int kvm_age_hva(struct kvm *kvm, unsigned long hva); 754 755 #endif /* _ASM_X86_KVM_HOST_H */ 756