1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _ASM_X86_KVM_PARA_H 3 #define _ASM_X86_KVM_PARA_H 4 5 #include <asm/processor.h> 6 #include <asm/alternative.h> 7 #include <linux/interrupt.h> 8 #include <uapi/asm/kvm_para.h> 9 10 #ifdef CONFIG_KVM_GUEST 11 bool kvm_check_and_clear_guest_paused(void); 12 #else 13 static inline bool kvm_check_and_clear_guest_paused(void) 14 { 15 return false; 16 } 17 #endif /* CONFIG_KVM_GUEST */ 18 19 #define KVM_HYPERCALL \ 20 ALTERNATIVE("vmcall", "vmmcall", X86_FEATURE_VMMCALL) 21 22 /* For KVM hypercalls, a three-byte sequence of either the vmcall or the vmmcall 23 * instruction. The hypervisor may replace it with something else but only the 24 * instructions are guaranteed to be supported. 25 * 26 * Up to four arguments may be passed in rbx, rcx, rdx, and rsi respectively. 27 * The hypercall number should be placed in rax and the return value will be 28 * placed in rax. No other registers will be clobbered unless explicitly 29 * noted by the particular hypercall. 30 */ 31 32 static inline long kvm_hypercall0(unsigned int nr) 33 { 34 long ret; 35 asm volatile(KVM_HYPERCALL 36 : "=a"(ret) 37 : "a"(nr) 38 : "memory"); 39 return ret; 40 } 41 42 static inline long kvm_hypercall1(unsigned int nr, unsigned long p1) 43 { 44 long ret; 45 asm volatile(KVM_HYPERCALL 46 : "=a"(ret) 47 : "a"(nr), "b"(p1) 48 : "memory"); 49 return ret; 50 } 51 52 static inline long kvm_hypercall2(unsigned int nr, unsigned long p1, 53 unsigned long p2) 54 { 55 long ret; 56 asm volatile(KVM_HYPERCALL 57 : "=a"(ret) 58 : "a"(nr), "b"(p1), "c"(p2) 59 : "memory"); 60 return ret; 61 } 62 63 static inline long kvm_hypercall3(unsigned int nr, unsigned long p1, 64 unsigned long p2, unsigned long p3) 65 { 66 long ret; 67 asm volatile(KVM_HYPERCALL 68 : "=a"(ret) 69 : "a"(nr), "b"(p1), "c"(p2), "d"(p3) 70 : "memory"); 71 return ret; 72 } 73 74 static inline long kvm_hypercall4(unsigned int nr, unsigned long p1, 75 unsigned long p2, unsigned long p3, 76 unsigned long p4) 77 { 78 long ret; 79 asm volatile(KVM_HYPERCALL 80 : "=a"(ret) 81 : "a"(nr), "b"(p1), "c"(p2), "d"(p3), "S"(p4) 82 : "memory"); 83 return ret; 84 } 85 86 #ifdef CONFIG_KVM_GUEST 87 void kvmclock_init(void); 88 void kvmclock_disable(void); 89 bool kvm_para_available(void); 90 unsigned int kvm_arch_para_features(void); 91 unsigned int kvm_arch_para_hints(void); 92 void kvm_async_pf_task_wait_schedule(u32 token); 93 void kvm_async_pf_task_wake(u32 token); 94 u32 kvm_read_and_reset_apf_flags(void); 95 bool __kvm_handle_async_pf(struct pt_regs *regs, u32 token); 96 97 DECLARE_STATIC_KEY_FALSE(kvm_async_pf_enabled); 98 99 static __always_inline bool kvm_handle_async_pf(struct pt_regs *regs, u32 token) 100 { 101 if (static_branch_unlikely(&kvm_async_pf_enabled)) 102 return __kvm_handle_async_pf(regs, token); 103 else 104 return false; 105 } 106 107 #ifdef CONFIG_PARAVIRT_SPINLOCKS 108 void __init kvm_spinlock_init(void); 109 #else /* !CONFIG_PARAVIRT_SPINLOCKS */ 110 static inline void kvm_spinlock_init(void) 111 { 112 } 113 #endif /* CONFIG_PARAVIRT_SPINLOCKS */ 114 115 #else /* CONFIG_KVM_GUEST */ 116 #define kvm_async_pf_task_wait_schedule(T) do {} while(0) 117 #define kvm_async_pf_task_wake(T) do {} while(0) 118 119 static inline bool kvm_para_available(void) 120 { 121 return false; 122 } 123 124 static inline unsigned int kvm_arch_para_features(void) 125 { 126 return 0; 127 } 128 129 static inline unsigned int kvm_arch_para_hints(void) 130 { 131 return 0; 132 } 133 134 static inline u32 kvm_read_and_reset_apf_flags(void) 135 { 136 return 0; 137 } 138 139 static __always_inline bool kvm_handle_async_pf(struct pt_regs *regs, u32 token) 140 { 141 return false; 142 } 143 #endif 144 145 #endif /* _ASM_X86_KVM_PARA_H */ 146