[apple/xnu.git] / osfmk / i386 / x86_hypercall.h

/*
 * Copyright (c) 2020 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

#ifndef _I386_X86_HYPERCALL_H_
#define _I386_X86_HYPERCALL_H_

#if DEBUG || DEVELOPMENT


/*
 * Apple Hypercall Calling Convention (x64)
 *
 * Registers |                Usage                       |
 * --------------------------------------------------------
 *      %rax |    In:  hypercall code                     |
 *           |    Out: if RFLAGS.CF = 0 (success)         |
 *           |           hypercall output[0]              |
 *           |         if RFLAGS.CF = 1 (error)           |
 *           |           hypercall error value            |
 *      %rdi |    In:  1st argument                       |
 *           |    Out: hypercall output[1]                |
 *      %rsi |    In:  2nd argument                       |
 *           |    Out: hypercall output[2]                |
 *      %rdx |    In:  3rd argument                       |
 *           |    Out: hypercall output[3]                |
 *      %rcx |    In:  4th argument                       |
 *           |    Out: hypercall output[4]                |
 *      %r8  |    In:  5th argument                       |
 *           |    Out: hypercall output[5]                |
 *      %r9  |    In:  6th argument                       |
 *           |    Out: hypercall output[6]                |
 *
 * %rax is used by the caller to specify hypercall code. When a hypercall fails,
 * the hypervisor stores errno in %rax. A successful hypercall returns the
 * output of the call in %rax, %rdi, %rsi, %rdx, %rcx, %r8, and %r9.
 */

typedef struct hvg_hcall_output_regs {
	uint64_t   rax;
	uint64_t   rdi;
	uint64_t   rsi;
	uint64_t   rdx;
	uint64_t   rcx;
	uint64_t   r8;
	uint64_t   r9;
} hvg_hcall_output_regs_t;

/*
 * To avoid collision with other hypercall interfaces (e.g., KVM) in the vmcall
 * namespace, Apple hypercalls put "A" (0x41) in the top byte of %eax so that
 * hypervisors can support multiple hypercall interfaces simultaneously and
 * handle Apple hypercalls correctly for compatiblity.
 *
 * For example, KVM uses the same vmcall instruction and has call code 1 for
 * KVM_HC_VAPIC_POLL_IRQ. When invoking an Apple hypercall with code 1, a
 * hypervisor will not accidentially treat the Apple hypercall as a KVM call.
 */

#define HVG_HCALL_CODE(code) ('A' << 24 | (code & 0xFFFFFF))


/*
 * Caller is responsible for checking the existence of Apple Hypercall
 * before invoking Apple hypercalls.
 */

#define HVG_HCALL_RETURN(rax) {\
	__asm__ __volatile__ goto (\
	                           "jnc 2f  \n\t" \
	                           "jmp %l0 \n\t" \
	                           "2:      \n\t" \
	                          : /* no output */ \
	                          : /* no input */  \
	                          : /* no clobber */ \
	                          : error);\
	return HVG_HCALL_SUCCESS;\
error:\
	return (hvg_hcall_return_t)rax;\
}

static inline hvg_hcall_return_t
hvg_hypercall6(uint64_t code, uint64_t rdi, uint64_t rsi, uint64_t rdx, uint64_t rcx, uint64_t r8, uint64_t r9,
    hvg_hcall_output_regs_t *output)
{
	__asm__ __volatile__ ("movq %12, %%r8  \n\t"
                          "movq %13, %%r9  \n\t"
                          "vmcall          \n\t"
                          "movq %%r8, %5   \n\t"
                          "movq %%r9, %6   \n\t"
                        : "=a" (output->rax),         /* %0:  output[0] */
                          "=D" (output->rdi),         /* %1:  output[1] */
                          "=S" (output->rsi),         /* %2:  output[2] */
                          "=d" (output->rdx),         /* %3:  output[3] */
                          "=c" (output->rcx),         /* %4:  output[4] */
                          "=r" (output->r8),          /* %5:  output[5] */
                          "=r" (output->r9)           /* %6:  output[6] */
                        : "a"  (HVG_HCALL_CODE(code)),/* %7:  call code */
                          "D"  (rdi),                 /* %8:  arg[0]    */
                          "S"  (rsi),                 /* %9:  arg[1]    */
                          "d"  (rdx),                 /* %10: arg[2]    */
                          "c"  (rcx),                 /* %11: arg[3]    */
                          "r"  (r8),                  /* %12: arg[4]    */
                          "r"  (r9)                   /* %13: arg[5]    */
                        : "memory", "r8", "r9");
	HVG_HCALL_RETURN(output->rax);
}

static inline hvg_hcall_return_t
hvg_hypercall0(const uint64_t code,
    hvg_hcall_output_regs_t *output)
{
	return hvg_hypercall6(code, 0, 0, 0, 0, 0, 0, output);
}

static inline hvg_hcall_return_t
hvg_hypercall1(const uint64_t code,
    const uint64_t rdi,
    hvg_hcall_output_regs_t *output)
{
	return hvg_hypercall6(code, rdi, 0, 0, 0, 0, 0, output);
}

static inline hvg_hcall_return_t
hvg_hypercall2(const uint64_t code,
    const uint64_t rdi, const uint64_t rsi,
    hvg_hcall_output_regs_t *output)
{
	return hvg_hypercall6(code, rdi, rsi, 0, 0, 0, 0, output);
}

static inline hvg_hcall_return_t
hvg_hypercall3(const uint64_t code,
    const uint64_t rdi, const uint64_t rsi, const uint64_t rdx,
    hvg_hcall_output_regs_t *output)
{
	return hvg_hypercall6(code, rdi, rsi, rdx, 0, 0, 0, output);
}

static inline hvg_hcall_return_t
hvg_hypercall4(const uint64_t code,
    const uint64_t rdi, const uint64_t rsi, const uint64_t rdx, const uint64_t rcx,
    hvg_hcall_output_regs_t *output)
{
	return hvg_hypercall6(code, rdi, rsi, rdx, rcx, 0, 0, output);
}

static inline hvg_hcall_return_t
hvg_hypercall5(const uint64_t code,
    const uint64_t rdi, const uint64_t rsi, const uint64_t rdx, const uint64_t rcx, const uint64_t r8,
    hvg_hcall_output_regs_t *output)
{
	return hvg_hypercall6(code, rdi, rsi, rdx, rcx, r8, 0, output);
}

#endif /* DEBUG || DEVELOPMENT */

#endif /* _I386_X86_HYPERCALL_H_ */
Commit	Line	Data
c3c9b80d A	1	/*
	2	* Copyright (c) 2020 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28
	29	#ifndef _I386_X86_HYPERCALL_H_
	30	#define _I386_X86_HYPERCALL_H_
	31
	32	#if DEBUG \|\| DEVELOPMENT
	33
	34
	35	/*
	36	* Apple Hypercall Calling Convention (x64)
	37	*
	38	* Registers \| Usage \|
	39	* --------------------------------------------------------
	40	* %rax \| In: hypercall code \|
	41	* \| Out: if RFLAGS.CF = 0 (success) \|
	42	* \| hypercall output[0] \|
	43	* \| if RFLAGS.CF = 1 (error) \|
	44	* \| hypercall error value \|
	45	* %rdi \| In: 1st argument \|
	46	* \| Out: hypercall output[1] \|
	47	* %rsi \| In: 2nd argument \|
	48	* \| Out: hypercall output[2] \|
	49	* %rdx \| In: 3rd argument \|
	50	* \| Out: hypercall output[3] \|
	51	* %rcx \| In: 4th argument \|
	52	* \| Out: hypercall output[4] \|
	53	* %r8 \| In: 5th argument \|
	54	* \| Out: hypercall output[5] \|
	55	* %r9 \| In: 6th argument \|
	56	* \| Out: hypercall output[6] \|
	57	*
	58	* %rax is used by the caller to specify hypercall code. When a hypercall fails,
	59	* the hypervisor stores errno in %rax. A successful hypercall returns the
	60	* output of the call in %rax, %rdi, %rsi, %rdx, %rcx, %r8, and %r9.
	61	*/
	62
	63	typedef struct hvg_hcall_output_regs {
	64	uint64_t rax;
65	uint64_t rdi;
66	uint64_t rsi;
67	uint64_t rdx;
68	uint64_t rcx;
69	uint64_t r8;
70	uint64_t r9;
71	} hvg_hcall_output_regs_t;
72
73	/*
74	* To avoid collision with other hypercall interfaces (e.g., KVM) in the vmcall
75	* namespace, Apple hypercalls put "A" (0x41) in the top byte of %eax so that
76	* hypervisors can support multiple hypercall interfaces simultaneously and
77	* handle Apple hypercalls correctly for compatiblity.
78	*
79	* For example, KVM uses the same vmcall instruction and has call code 1 for
80	* KVM_HC_VAPIC_POLL_IRQ. When invoking an Apple hypercall with code 1, a
81	* hypervisor will not accidentially treat the Apple hypercall as a KVM call.
82	*/
83
84	#define HVG_HCALL_CODE(code) ('A' << 24 \| (code & 0xFFFFFF))
85
86
87	/*
88	* Caller is responsible for checking the existence of Apple Hypercall
89	* before invoking Apple hypercalls.
90	*/
91
92	#define HVG_HCALL_RETURN(rax) {\
93	__asm__ __volatile__ goto (\
94	"jnc 2f \n\t" \
95	"jmp %l0 \n\t" \
96	"2: \n\t" \
97	: /* no output */ \
98	: /* no input */ \
99	: /* no clobber */ \
100	: error);\
101	return HVG_HCALL_SUCCESS;\
102	error:\
103	return (hvg_hcall_return_t)rax;\
104	}
105
106	static inline hvg_hcall_return_t
107	hvg_hypercall6(uint64_t code, uint64_t rdi, uint64_t rsi, uint64_t rdx, uint64_t rcx, uint64_t r8, uint64_t r9,
108	hvg_hcall_output_regs_t *output)
109	{
110	__asm__ __volatile__ ("movq %12, %%r8 \n\t"
111	"movq %13, %%r9 \n\t"
112	"vmcall \n\t"
113	"movq %%r8, %5 \n\t"
114	"movq %%r9, %6 \n\t"
115	: "=a" (output->rax), /* %0: output[0] */
116	"=D" (output->rdi), /* %1: output[1] */
117	"=S" (output->rsi), /* %2: output[2] */
118	"=d" (output->rdx), /* %3: output[3] */
119	"=c" (output->rcx), /* %4: output[4] */
120	"=r" (output->r8), /* %5: output[5] */
121	"=r" (output->r9) /* %6: output[6] */
122	: "a" (HVG_HCALL_CODE(code)),/* %7: call code */
123	"D" (rdi), /* %8: arg[0] */
124	"S" (rsi), /* %9: arg[1] */
125	"d" (rdx), /* %10: arg[2] */
126	"c" (rcx), /* %11: arg[3] */
127	"r" (r8), /* %12: arg[4] */
128	"r" (r9) /* %13: arg[5] */
129	: "memory", "r8", "r9");
130	HVG_HCALL_RETURN(output->rax);
131	}
132
133	static inline hvg_hcall_return_t
134	hvg_hypercall0(const uint64_t code,
135	hvg_hcall_output_regs_t *output)
136	{
137	return hvg_hypercall6(code, 0, 0, 0, 0, 0, 0, output);
138	}
139
140	static inline hvg_hcall_return_t
141	hvg_hypercall1(const uint64_t code,
142	const uint64_t rdi,
143	hvg_hcall_output_regs_t *output)
144	{
145	return hvg_hypercall6(code, rdi, 0, 0, 0, 0, 0, output);
146	}
147
148	static inline hvg_hcall_return_t
149	hvg_hypercall2(const uint64_t code,
150	const uint64_t rdi, const uint64_t rsi,
151	hvg_hcall_output_regs_t *output)
152	{
153	return hvg_hypercall6(code, rdi, rsi, 0, 0, 0, 0, output);
154	}
155
156	static inline hvg_hcall_return_t
157	hvg_hypercall3(const uint64_t code,
158	const uint64_t rdi, const uint64_t rsi, const uint64_t rdx,
159	hvg_hcall_output_regs_t *output)
160	{
161	return hvg_hypercall6(code, rdi, rsi, rdx, 0, 0, 0, output);
162	}
163
164	static inline hvg_hcall_return_t
165	hvg_hypercall4(const uint64_t code,
166	const uint64_t rdi, const uint64_t rsi, const uint64_t rdx, const uint64_t rcx,
167	hvg_hcall_output_regs_t *output)
168	{
169	return hvg_hypercall6(code, rdi, rsi, rdx, rcx, 0, 0, output);
170	}
171
172	static inline hvg_hcall_return_t
173	hvg_hypercall5(const uint64_t code,
174	const uint64_t rdi, const uint64_t rsi, const uint64_t rdx, const uint64_t rcx, const uint64_t r8,
175	hvg_hcall_output_regs_t *output)
176	{
177	return hvg_hypercall6(code, rdi, rsi, rdx, rcx, r8, 0, output);
178	}
179
180	#endif /* DEBUG \|\| DEVELOPMENT */
181
182	#endif /* _I386_X86_HYPERCALL_H_ */