[linux-2.6-block.git] / arch / x86 / include / asm / kvm_para.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _ASM_X86_KVM_PARA_H
#define _ASM_X86_KVM_PARA_H

#include <asm/processor.h>
#include <asm/alternative.h>
#include <uapi/asm/kvm_para.h>

extern void kvmclock_init(void);

#ifdef CONFIG_KVM_GUEST
bool kvm_check_and_clear_guest_paused(void);
#else
static inline bool kvm_check_and_clear_guest_paused(void)
{
	return false;
}
#endif /* CONFIG_KVM_GUEST */

#define KVM_HYPERCALL \
        ALTERNATIVE(".byte 0x0f,0x01,0xc1", ".byte 0x0f,0x01,0xd9", X86_FEATURE_VMMCALL)

/* For KVM hypercalls, a three-byte sequence of either the vmcall or the vmmcall
 * instruction.  The hypervisor may replace it with something else but only the
 * instructions are guaranteed to be supported.
 *
 * Up to four arguments may be passed in rbx, rcx, rdx, and rsi respectively.
 * The hypercall number should be placed in rax and the return value will be
 * placed in rax.  No other registers will be clobbered unless explicitly
 * noted by the particular hypercall.
 */

static inline long kvm_hypercall0(unsigned int nr)
{
	long ret;
	asm volatile(KVM_HYPERCALL
		     : "=a"(ret)
		     : "a"(nr)
		     : "memory");
	return ret;
}

static inline long kvm_hypercall1(unsigned int nr, unsigned long p1)
{
	long ret;
	asm volatile(KVM_HYPERCALL
		     : "=a"(ret)
		     : "a"(nr), "b"(p1)
		     : "memory");
	return ret;
}

static inline long kvm_hypercall2(unsigned int nr, unsigned long p1,
				  unsigned long p2)
{
	long ret;
	asm volatile(KVM_HYPERCALL
		     : "=a"(ret)
		     : "a"(nr), "b"(p1), "c"(p2)
		     : "memory");
	return ret;
}

static inline long kvm_hypercall3(unsigned int nr, unsigned long p1,
				  unsigned long p2, unsigned long p3)
{
	long ret;
	asm volatile(KVM_HYPERCALL
		     : "=a"(ret)
		     : "a"(nr), "b"(p1), "c"(p2), "d"(p3)
		     : "memory");
	return ret;
}

static inline long kvm_hypercall4(unsigned int nr, unsigned long p1,
				  unsigned long p2, unsigned long p3,
				  unsigned long p4)
{
	long ret;
	asm volatile(KVM_HYPERCALL
		     : "=a"(ret)
		     : "a"(nr), "b"(p1), "c"(p2), "d"(p3), "S"(p4)
		     : "memory");
	return ret;
}

#ifdef CONFIG_KVM_GUEST
bool kvm_para_available(void);
unsigned int kvm_arch_para_features(void);
unsigned int kvm_arch_para_hints(void);
void kvm_async_pf_task_wait(u32 token, int interrupt_kernel);
void kvm_async_pf_task_wake(u32 token);
u32 kvm_read_and_reset_pf_reason(void);
extern void kvm_disable_steal_time(void);
void do_async_page_fault(struct pt_regs *regs, unsigned long error_code);

#ifdef CONFIG_PARAVIRT_SPINLOCKS
void __init kvm_spinlock_init(void);
#else /* !CONFIG_PARAVIRT_SPINLOCKS */
static inline void kvm_spinlock_init(void)
{
}
#endif /* CONFIG_PARAVIRT_SPINLOCKS */

#else /* CONFIG_KVM_GUEST */
#define kvm_async_pf_task_wait(T, I) do {} while(0)
#define kvm_async_pf_task_wake(T) do {} while(0)

static inline bool kvm_para_available(void)
{
	return false;
}

static inline unsigned int kvm_arch_para_features(void)
{
	return 0;
}

static inline unsigned int kvm_arch_para_hints(void)
{
	return 0;
}

static inline u32 kvm_read_and_reset_pf_reason(void)
{
	return 0;
}

static inline void kvm_disable_steal_time(void)
{
	return;
}
#endif

#endif /* _ASM_X86_KVM_PARA_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
1965aae3 PA	2	#ifndef _ASM_X86_KVM_PARA_H
1965aae3 PA	3	#define _ASM_X86_KVM_PARA_H
5f43238d	4
5f43238d	5	#include <asm/processor.h>
c1118b36	6	#include <asm/alternative.h>
af170c50	7	#include <uapi/asm/kvm_para.h>
5f43238d	8
18068523 GOC	9	extern void kvmclock_init(void);
18068523 GOC	10
90993cdd	11	#ifdef CONFIG_KVM_GUEST
3b5d56b9 EM	12	bool kvm_check_and_clear_guest_paused(void);
	13	#else
	14	static inline bool kvm_check_and_clear_guest_paused(void)
	15	{
	16	return false;
	17	}
90993cdd	18	#endif /* CONFIG_KVM_GUEST */
18068523	19
c1118b36 PB	20	#define KVM_HYPERCALL \
c1118b36 PB	21	ALTERNATIVE(".byte 0x0f,0x01,0xc1", ".byte 0x0f,0x01,0xd9", X86_FEATURE_VMMCALL)
5f43238d	22
e423ca15	23	/* For KVM hypercalls, a three-byte sequence of either the vmcall or the vmmcall
5f43238d CB	24	* instruction. The hypervisor may replace it with something else but only the
	25	* instructions are guaranteed to be supported.
	26	*
	27	* Up to four arguments may be passed in rbx, rcx, rdx, and rsi respectively.
	28	* The hypercall number should be placed in rax and the return value will be
11393a07	29	* placed in rax. No other registers will be clobbered unless explicitly
5f43238d CB	30	* noted by the particular hypercall.
	31	*/
	32
	33	static inline long kvm_hypercall0(unsigned int nr)
	34	{
	35	long ret;
	36	asm volatile(KVM_HYPERCALL
	37	: "=a"(ret)
ca373932 AL	38	: "a"(nr)
ca373932 AL	39	: "memory");
5f43238d CB	40	return ret;
	41	}
	42
	43	static inline long kvm_hypercall1(unsigned int nr, unsigned long p1)
	44	{
	45	long ret;
	46	asm volatile(KVM_HYPERCALL
	47	: "=a"(ret)
ca373932 AL	48	: "a"(nr), "b"(p1)
ca373932 AL	49	: "memory");
5f43238d CB	50	return ret;
	51	}
	52
	53	static inline long kvm_hypercall2(unsigned int nr, unsigned long p1,
	54	unsigned long p2)
	55	{
	56	long ret;
	57	asm volatile(KVM_HYPERCALL
	58	: "=a"(ret)
ca373932 AL	59	: "a"(nr), "b"(p1), "c"(p2)
ca373932 AL	60	: "memory");
5f43238d CB	61	return ret;
	62	}
	63
	64	static inline long kvm_hypercall3(unsigned int nr, unsigned long p1,
	65	unsigned long p2, unsigned long p3)
	66	{
	67	long ret;
	68	asm volatile(KVM_HYPERCALL
	69	: "=a"(ret)
ca373932 AL	70	: "a"(nr), "b"(p1), "c"(p2), "d"(p3)
ca373932 AL	71	: "memory");
5f43238d CB	72	return ret;
	73	}
	74
	75	static inline long kvm_hypercall4(unsigned int nr, unsigned long p1,
	76	unsigned long p2, unsigned long p3,
	77	unsigned long p4)
	78	{
	79	long ret;
	80	asm volatile(KVM_HYPERCALL
	81	: "=a"(ret)
ca373932 AL	82	: "a"(nr), "b"(p1), "c"(p2), "d"(p3), "S"(p4)
ca373932 AL	83	: "memory");
5f43238d CB	84	return ret;
	85	}
	86
ba492962	87	#ifdef CONFIG_KVM_GUEST
1c300a40	88	bool kvm_para_available(void);
77f01bdf	89	unsigned int kvm_arch_para_features(void);
a4429e53	90	unsigned int kvm_arch_para_hints(void);
a2b7861b	91	void kvm_async_pf_task_wait(u32 token, int interrupt_kernel);
631bc487 GN	92	void kvm_async_pf_task_wake(u32 token);
631bc487 GN	93	u32 kvm_read_and_reset_pf_reason(void);
d910f5c1	94	extern void kvm_disable_steal_time(void);
89f579ce	95	void do_async_page_fault(struct pt_regs *regs, unsigned long error_code);
92b75202 SV	96
	97	#ifdef CONFIG_PARAVIRT_SPINLOCKS
	98	void __init kvm_spinlock_init(void);
	99	#else /* !CONFIG_PARAVIRT_SPINLOCKS */
	100	static inline void kvm_spinlock_init(void)
	101	{
	102	}
	103	#endif /* CONFIG_PARAVIRT_SPINLOCKS */
	104
	105	#else /* CONFIG_KVM_GUEST */
a2b7861b	106	#define kvm_async_pf_task_wait(T, I) do {} while(0)
631bc487	107	#define kvm_async_pf_task_wake(T) do {} while(0)
92b75202	108
1c300a40 PB	109	static inline bool kvm_para_available(void)
1c300a40 PB	110	{
1d804d07	111	return false;
1c300a40 PB	112	}
1c300a40 PB	113
77f01bdf PB	114	static inline unsigned int kvm_arch_para_features(void)
	115	{
	116	return 0;
	117	}
	118
a4429e53 WL	119	static inline unsigned int kvm_arch_para_hints(void)
	120	{
	121	return 0;
	122	}
	123
d4c90b00	124	static inline u32 kvm_read_and_reset_pf_reason(void)
631bc487 GN	125	{
	126	return 0;
	127	}
d910f5c1 GC	128
	129	static inline void kvm_disable_steal_time(void)
	130	{
	131	return;
	132	}
5f43238d CB	133	#endif
5f43238d CB	134
1965aae3	135	#endif /* _ASM_X86_KVM_PARA_H */