1 /******************************************************************************
4 * Linux-specific hypervisor handling.
6 * Copyright (c) 2002-2004, K A Fraser
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version 2
10 * as published by the Free Software Foundation; or, when distributed
11 * separately from the Linux kernel or incorporated into other
12 * software packages, subject to the following license:
14 * Permission is hereby granted, free of charge, to any person obtaining a copy
15 * of this source file (the "Software"), to deal in the Software without
16 * restriction, including without limitation the rights to use, copy, modify,
17 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
18 * and to permit persons to whom the Software is furnished to do so, subject to
19 * the following conditions:
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
33 #ifndef _ASM_X86_XEN_HYPERCALL_H
34 #define _ASM_X86_XEN_HYPERCALL_H
36 #include <linux/kernel.h>
37 #include <linux/spinlock.h>
38 #include <linux/errno.h>
39 #include <linux/string.h>
40 #include <linux/types.h>
42 #include <trace/events/xen.h>
45 #include <asm/pgtable.h>
48 #include <xen/interface/xen.h>
49 #include <xen/interface/sched.h>
50 #include <xen/interface/physdev.h>
51 #include <xen/interface/platform.h>
52 #include <xen/interface/xen-mca.h>
57 * The hypercall asms have to meet several constraints:
58 * - Work on 32- and 64-bit.
59 * The two architectures put their arguments in different sets of
62 * - Work around asm syntax quirks
63 * It isn't possible to specify one of the rNN registers in a
64 * constraint, so we use explicit register variables to get the
65 * args into the right place.
67 * - Mark all registers as potentially clobbered
68 * Even unused parameters can be clobbered by the hypervisor, so we
69 * need to make sure gcc knows it.
71 * - Avoid compiler bugs.
72 * This is the tricky part. Because x86_32 has such a constrained
73 * register set, gcc versions below 4.3 have trouble generating
74 * code when all the arg registers and memory are trashed by the
75 * asm. There are syntactically simpler ways of achieving the
76 * semantics below, but they cause the compiler to crash.
78 * The only combination I found which works is:
79 * - assign the __argX variables first
80 * - list all actually used parameters as "+r" (__argX)
83 * The result certainly isn't pretty, and it really shows up cpp's
84 * weakness as as macro language. Sorry. (But let's just give thanks
85 * there aren't more than 5 arguments...)
88 extern struct { char _entry
[32]; } hypercall_page
[];
90 #define __HYPERCALL "call hypercall_page+%c[offset]"
91 #define __HYPERCALL_ENTRY(x) \
92 [offset] "i" (__HYPERVISOR_##x * sizeof(hypercall_page[0]))
95 #define __HYPERCALL_RETREG "eax"
96 #define __HYPERCALL_ARG1REG "ebx"
97 #define __HYPERCALL_ARG2REG "ecx"
98 #define __HYPERCALL_ARG3REG "edx"
99 #define __HYPERCALL_ARG4REG "esi"
100 #define __HYPERCALL_ARG5REG "edi"
102 #define __HYPERCALL_RETREG "rax"
103 #define __HYPERCALL_ARG1REG "rdi"
104 #define __HYPERCALL_ARG2REG "rsi"
105 #define __HYPERCALL_ARG3REG "rdx"
106 #define __HYPERCALL_ARG4REG "r10"
107 #define __HYPERCALL_ARG5REG "r8"
110 #define __HYPERCALL_DECLS \
111 register unsigned long __res asm(__HYPERCALL_RETREG); \
112 register unsigned long __arg1 asm(__HYPERCALL_ARG1REG) = __arg1; \
113 register unsigned long __arg2 asm(__HYPERCALL_ARG2REG) = __arg2; \
114 register unsigned long __arg3 asm(__HYPERCALL_ARG3REG) = __arg3; \
115 register unsigned long __arg4 asm(__HYPERCALL_ARG4REG) = __arg4; \
116 register unsigned long __arg5 asm(__HYPERCALL_ARG5REG) = __arg5;
118 #define __HYPERCALL_0PARAM "=r" (__res), ASM_CALL_CONSTRAINT
119 #define __HYPERCALL_1PARAM __HYPERCALL_0PARAM, "+r" (__arg1)
120 #define __HYPERCALL_2PARAM __HYPERCALL_1PARAM, "+r" (__arg2)
121 #define __HYPERCALL_3PARAM __HYPERCALL_2PARAM, "+r" (__arg3)
122 #define __HYPERCALL_4PARAM __HYPERCALL_3PARAM, "+r" (__arg4)
123 #define __HYPERCALL_5PARAM __HYPERCALL_4PARAM, "+r" (__arg5)
125 #define __HYPERCALL_0ARG()
126 #define __HYPERCALL_1ARG(a1) \
127 __HYPERCALL_0ARG() __arg1 = (unsigned long)(a1);
128 #define __HYPERCALL_2ARG(a1,a2) \
129 __HYPERCALL_1ARG(a1) __arg2 = (unsigned long)(a2);
130 #define __HYPERCALL_3ARG(a1,a2,a3) \
131 __HYPERCALL_2ARG(a1,a2) __arg3 = (unsigned long)(a3);
132 #define __HYPERCALL_4ARG(a1,a2,a3,a4) \
133 __HYPERCALL_3ARG(a1,a2,a3) __arg4 = (unsigned long)(a4);
134 #define __HYPERCALL_5ARG(a1,a2,a3,a4,a5) \
135 __HYPERCALL_4ARG(a1,a2,a3,a4) __arg5 = (unsigned long)(a5);
137 #define __HYPERCALL_CLOBBER5 "memory"
138 #define __HYPERCALL_CLOBBER4 __HYPERCALL_CLOBBER5, __HYPERCALL_ARG5REG
139 #define __HYPERCALL_CLOBBER3 __HYPERCALL_CLOBBER4, __HYPERCALL_ARG4REG
140 #define __HYPERCALL_CLOBBER2 __HYPERCALL_CLOBBER3, __HYPERCALL_ARG3REG
141 #define __HYPERCALL_CLOBBER1 __HYPERCALL_CLOBBER2, __HYPERCALL_ARG2REG
142 #define __HYPERCALL_CLOBBER0 __HYPERCALL_CLOBBER1, __HYPERCALL_ARG1REG
144 #define _hypercall0(type, name) \
147 __HYPERCALL_0ARG(); \
148 asm volatile (__HYPERCALL \
149 : __HYPERCALL_0PARAM \
150 : __HYPERCALL_ENTRY(name) \
151 : __HYPERCALL_CLOBBER0); \
155 #define _hypercall1(type, name, a1) \
158 __HYPERCALL_1ARG(a1); \
159 asm volatile (__HYPERCALL \
160 : __HYPERCALL_1PARAM \
161 : __HYPERCALL_ENTRY(name) \
162 : __HYPERCALL_CLOBBER1); \
166 #define _hypercall2(type, name, a1, a2) \
169 __HYPERCALL_2ARG(a1, a2); \
170 asm volatile (__HYPERCALL \
171 : __HYPERCALL_2PARAM \
172 : __HYPERCALL_ENTRY(name) \
173 : __HYPERCALL_CLOBBER2); \
177 #define _hypercall3(type, name, a1, a2, a3) \
180 __HYPERCALL_3ARG(a1, a2, a3); \
181 asm volatile (__HYPERCALL \
182 : __HYPERCALL_3PARAM \
183 : __HYPERCALL_ENTRY(name) \
184 : __HYPERCALL_CLOBBER3); \
188 #define _hypercall4(type, name, a1, a2, a3, a4) \
191 __HYPERCALL_4ARG(a1, a2, a3, a4); \
192 asm volatile (__HYPERCALL \
193 : __HYPERCALL_4PARAM \
194 : __HYPERCALL_ENTRY(name) \
195 : __HYPERCALL_CLOBBER4); \
199 #define _hypercall5(type, name, a1, a2, a3, a4, a5) \
202 __HYPERCALL_5ARG(a1, a2, a3, a4, a5); \
203 asm volatile (__HYPERCALL \
204 : __HYPERCALL_5PARAM \
205 : __HYPERCALL_ENTRY(name) \
206 : __HYPERCALL_CLOBBER5); \
211 privcmd_call(unsigned call
,
212 unsigned long a1
, unsigned long a2
,
213 unsigned long a3
, unsigned long a4
,
217 __HYPERCALL_5ARG(a1
, a2
, a3
, a4
, a5
);
220 asm volatile("call *%[call]"
222 : [call
] "a" (&hypercall_page
[call
])
223 : __HYPERCALL_CLOBBER5
);
230 HYPERVISOR_set_trap_table(struct trap_info
*table
)
232 return _hypercall1(int, set_trap_table
, table
);
236 HYPERVISOR_mmu_update(struct mmu_update
*req
, int count
,
237 int *success_count
, domid_t domid
)
239 return _hypercall4(int, mmu_update
, req
, count
, success_count
, domid
);
243 HYPERVISOR_mmuext_op(struct mmuext_op
*op
, int count
,
244 int *success_count
, domid_t domid
)
246 return _hypercall4(int, mmuext_op
, op
, count
, success_count
, domid
);
250 HYPERVISOR_set_gdt(unsigned long *frame_list
, int entries
)
252 return _hypercall2(int, set_gdt
, frame_list
, entries
);
256 HYPERVISOR_stack_switch(unsigned long ss
, unsigned long esp
)
258 return _hypercall2(int, stack_switch
, ss
, esp
);
263 HYPERVISOR_set_callbacks(unsigned long event_selector
,
264 unsigned long event_address
,
265 unsigned long failsafe_selector
,
266 unsigned long failsafe_address
)
268 return _hypercall4(int, set_callbacks
,
269 event_selector
, event_address
,
270 failsafe_selector
, failsafe_address
);
272 #else /* CONFIG_X86_64 */
274 HYPERVISOR_set_callbacks(unsigned long event_address
,
275 unsigned long failsafe_address
,
276 unsigned long syscall_address
)
278 return _hypercall3(int, set_callbacks
,
279 event_address
, failsafe_address
,
282 #endif /* CONFIG_X86_{32,64} */
285 HYPERVISOR_callback_op(int cmd
, void *arg
)
287 return _hypercall2(int, callback_op
, cmd
, arg
);
291 HYPERVISOR_fpu_taskswitch(int set
)
293 return _hypercall1(int, fpu_taskswitch
, set
);
297 HYPERVISOR_sched_op(int cmd
, void *arg
)
299 return _hypercall2(int, sched_op
, cmd
, arg
);
303 HYPERVISOR_set_timer_op(u64 timeout
)
305 unsigned long timeout_hi
= (unsigned long)(timeout
>>32);
306 unsigned long timeout_lo
= (unsigned long)timeout
;
307 return _hypercall2(long, set_timer_op
, timeout_lo
, timeout_hi
);
311 HYPERVISOR_mca(struct xen_mc
*mc_op
)
313 mc_op
->interface_version
= XEN_MCA_INTERFACE_VERSION
;
314 return _hypercall1(int, mca
, mc_op
);
318 HYPERVISOR_platform_op(struct xen_platform_op
*op
)
320 op
->interface_version
= XENPF_INTERFACE_VERSION
;
321 return _hypercall1(int, platform_op
, op
);
325 HYPERVISOR_set_debugreg(int reg
, unsigned long value
)
327 return _hypercall2(int, set_debugreg
, reg
, value
);
330 static inline unsigned long
331 HYPERVISOR_get_debugreg(int reg
)
333 return _hypercall1(unsigned long, get_debugreg
, reg
);
337 HYPERVISOR_update_descriptor(u64 ma
, u64 desc
)
339 if (sizeof(u64
) == sizeof(long))
340 return _hypercall2(int, update_descriptor
, ma
, desc
);
341 return _hypercall4(int, update_descriptor
, ma
, ma
>>32, desc
, desc
>>32);
345 HYPERVISOR_memory_op(unsigned int cmd
, void *arg
)
347 return _hypercall2(long, memory_op
, cmd
, arg
);
351 HYPERVISOR_multicall(void *call_list
, uint32_t nr_calls
)
353 return _hypercall2(int, multicall
, call_list
, nr_calls
);
357 HYPERVISOR_update_va_mapping(unsigned long va
, pte_t new_val
,
360 if (sizeof(new_val
) == sizeof(long))
361 return _hypercall3(int, update_va_mapping
, va
,
364 return _hypercall4(int, update_va_mapping
, va
,
365 new_val
.pte
, new_val
.pte
>> 32, flags
);
367 extern int __must_check
xen_event_channel_op_compat(int, void *);
370 HYPERVISOR_event_channel_op(int cmd
, void *arg
)
372 int rc
= _hypercall2(int, event_channel_op
, cmd
, arg
);
373 if (unlikely(rc
== -ENOSYS
))
374 rc
= xen_event_channel_op_compat(cmd
, arg
);
379 HYPERVISOR_xen_version(int cmd
, void *arg
)
381 return _hypercall2(int, xen_version
, cmd
, arg
);
385 HYPERVISOR_console_io(int cmd
, int count
, char *str
)
387 return _hypercall3(int, console_io
, cmd
, count
, str
);
390 extern int __must_check
xen_physdev_op_compat(int, void *);
393 HYPERVISOR_physdev_op(int cmd
, void *arg
)
395 int rc
= _hypercall2(int, physdev_op
, cmd
, arg
);
396 if (unlikely(rc
== -ENOSYS
))
397 rc
= xen_physdev_op_compat(cmd
, arg
);
402 HYPERVISOR_grant_table_op(unsigned int cmd
, void *uop
, unsigned int count
)
404 return _hypercall3(int, grant_table_op
, cmd
, uop
, count
);
408 HYPERVISOR_update_va_mapping_otherdomain(unsigned long va
, pte_t new_val
,
409 unsigned long flags
, domid_t domid
)
411 if (sizeof(new_val
) == sizeof(long))
412 return _hypercall4(int, update_va_mapping_otherdomain
, va
,
413 new_val
.pte
, flags
, domid
);
415 return _hypercall5(int, update_va_mapping_otherdomain
, va
,
416 new_val
.pte
, new_val
.pte
>> 32,
421 HYPERVISOR_vm_assist(unsigned int cmd
, unsigned int type
)
423 return _hypercall2(int, vm_assist
, cmd
, type
);
427 HYPERVISOR_vcpu_op(int cmd
, int vcpuid
, void *extra_args
)
429 return _hypercall3(int, vcpu_op
, cmd
, vcpuid
, extra_args
);
434 HYPERVISOR_set_segment_base(int reg
, unsigned long value
)
436 return _hypercall2(int, set_segment_base
, reg
, value
);
441 HYPERVISOR_suspend(unsigned long start_info_mfn
)
443 struct sched_shutdown r
= { .reason
= SHUTDOWN_suspend
};
446 * For a PV guest the tools require that the start_info mfn be
447 * present in rdx/edx when the hypercall is made. Per the
448 * hypercall calling convention this is the third hypercall
449 * argument, which is start_info_mfn here.
451 return _hypercall3(int, sched_op
, SCHEDOP_shutdown
, &r
, start_info_mfn
);
455 HYPERVISOR_nmi_op(unsigned long op
, unsigned long arg
)
457 return _hypercall2(int, nmi_op
, op
, arg
);
460 static inline unsigned long __must_check
461 HYPERVISOR_hvm_op(int op
, void *arg
)
463 return _hypercall2(unsigned long, hvm_op
, op
, arg
);
470 return _hypercall1(int, tmem_op
, op
);
474 HYPERVISOR_xenpmu_op(unsigned int op
, void *arg
)
476 return _hypercall2(int, xenpmu_op
, op
, arg
);
481 domid_t dom
, unsigned int nr_bufs
, struct xen_dm_op_buf
*bufs
)
485 ret
= _hypercall3(int, dm_op
, dom
, nr_bufs
, bufs
);
491 MULTI_fpu_taskswitch(struct multicall_entry
*mcl
, int set
)
493 mcl
->op
= __HYPERVISOR_fpu_taskswitch
;
496 trace_xen_mc_entry(mcl
, 1);
500 MULTI_update_va_mapping(struct multicall_entry
*mcl
, unsigned long va
,
501 pte_t new_val
, unsigned long flags
)
503 mcl
->op
= __HYPERVISOR_update_va_mapping
;
505 if (sizeof(new_val
) == sizeof(long)) {
506 mcl
->args
[1] = new_val
.pte
;
507 mcl
->args
[2] = flags
;
509 mcl
->args
[1] = new_val
.pte
;
510 mcl
->args
[2] = new_val
.pte
>> 32;
511 mcl
->args
[3] = flags
;
514 trace_xen_mc_entry(mcl
, sizeof(new_val
) == sizeof(long) ? 3 : 4);
518 MULTI_grant_table_op(struct multicall_entry
*mcl
, unsigned int cmd
,
519 void *uop
, unsigned int count
)
521 mcl
->op
= __HYPERVISOR_grant_table_op
;
523 mcl
->args
[1] = (unsigned long)uop
;
524 mcl
->args
[2] = count
;
526 trace_xen_mc_entry(mcl
, 3);
530 MULTI_update_va_mapping_otherdomain(struct multicall_entry
*mcl
, unsigned long va
,
531 pte_t new_val
, unsigned long flags
,
534 mcl
->op
= __HYPERVISOR_update_va_mapping_otherdomain
;
536 if (sizeof(new_val
) == sizeof(long)) {
537 mcl
->args
[1] = new_val
.pte
;
538 mcl
->args
[2] = flags
;
539 mcl
->args
[3] = domid
;
541 mcl
->args
[1] = new_val
.pte
;
542 mcl
->args
[2] = new_val
.pte
>> 32;
543 mcl
->args
[3] = flags
;
544 mcl
->args
[4] = domid
;
547 trace_xen_mc_entry(mcl
, sizeof(new_val
) == sizeof(long) ? 4 : 5);
551 MULTI_update_descriptor(struct multicall_entry
*mcl
, u64 maddr
,
552 struct desc_struct desc
)
554 u32
*p
= (u32
*) &desc
;
556 mcl
->op
= __HYPERVISOR_update_descriptor
;
557 if (sizeof(maddr
) == sizeof(long)) {
558 mcl
->args
[0] = maddr
;
559 mcl
->args
[1] = *(unsigned long *)&desc
;
561 mcl
->args
[0] = maddr
;
562 mcl
->args
[1] = maddr
>> 32;
567 trace_xen_mc_entry(mcl
, sizeof(maddr
) == sizeof(long) ? 2 : 4);
571 MULTI_memory_op(struct multicall_entry
*mcl
, unsigned int cmd
, void *arg
)
573 mcl
->op
= __HYPERVISOR_memory_op
;
575 mcl
->args
[1] = (unsigned long)arg
;
577 trace_xen_mc_entry(mcl
, 2);
581 MULTI_mmu_update(struct multicall_entry
*mcl
, struct mmu_update
*req
,
582 int count
, int *success_count
, domid_t domid
)
584 mcl
->op
= __HYPERVISOR_mmu_update
;
585 mcl
->args
[0] = (unsigned long)req
;
586 mcl
->args
[1] = count
;
587 mcl
->args
[2] = (unsigned long)success_count
;
588 mcl
->args
[3] = domid
;
590 trace_xen_mc_entry(mcl
, 4);
594 MULTI_mmuext_op(struct multicall_entry
*mcl
, struct mmuext_op
*op
, int count
,
595 int *success_count
, domid_t domid
)
597 mcl
->op
= __HYPERVISOR_mmuext_op
;
598 mcl
->args
[0] = (unsigned long)op
;
599 mcl
->args
[1] = count
;
600 mcl
->args
[2] = (unsigned long)success_count
;
601 mcl
->args
[3] = domid
;
603 trace_xen_mc_entry(mcl
, 4);
607 MULTI_set_gdt(struct multicall_entry
*mcl
, unsigned long *frames
, int entries
)
609 mcl
->op
= __HYPERVISOR_set_gdt
;
610 mcl
->args
[0] = (unsigned long)frames
;
611 mcl
->args
[1] = entries
;
613 trace_xen_mc_entry(mcl
, 2);
617 MULTI_stack_switch(struct multicall_entry
*mcl
,
618 unsigned long ss
, unsigned long esp
)
620 mcl
->op
= __HYPERVISOR_stack_switch
;
624 trace_xen_mc_entry(mcl
, 2);
627 #endif /* _ASM_X86_XEN_HYPERCALL_H */