1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * syscall_wrapper.h - x86 specific wrappers to syscall definitions |
4 | */ |
5 | |
6 | #ifndef _ASM_X86_SYSCALL_WRAPPER_H |
7 | #define _ASM_X86_SYSCALL_WRAPPER_H |
8 | |
9 | #include <asm/ptrace.h> |
10 | |
11 | extern long __x64_sys_ni_syscall(const struct pt_regs *regs); |
12 | extern long __ia32_sys_ni_syscall(const struct pt_regs *regs); |
13 | |
14 | /* |
15 | * Instead of the generic __SYSCALL_DEFINEx() definition, the x86 version takes |
16 | * struct pt_regs *regs as the only argument of the syscall stub(s) named as: |
17 | * __x64_sys_*() - 64-bit native syscall |
18 | * __ia32_sys_*() - 32-bit native syscall or common compat syscall |
19 | * __ia32_compat_sys_*() - 32-bit compat syscall |
20 | * __x64_compat_sys_*() - 64-bit X32 compat syscall |
21 | * |
22 | * The registers are decoded according to the ABI: |
23 | * 64-bit: RDI, RSI, RDX, R10, R8, R9 |
24 | * 32-bit: EBX, ECX, EDX, ESI, EDI, EBP |
25 | * |
26 | * The stub then passes the decoded arguments to the __se_sys_*() wrapper to |
27 | * perform sign-extension (omitted for zero-argument syscalls). Finally the |
28 | * arguments are passed to the __do_sys_*() function which is the actual |
29 | * syscall. These wrappers are marked as inline so the compiler can optimize |
30 | * the functions where appropriate. |
31 | * |
32 | * Example assembly (slightly re-ordered for better readability): |
33 | * |
34 | * <__x64_sys_recv>: <-- syscall with 4 parameters |
35 | * callq <__fentry__> |
36 | * |
37 | * mov 0x70(%rdi),%rdi <-- decode regs->di |
38 | * mov 0x68(%rdi),%rsi <-- decode regs->si |
39 | * mov 0x60(%rdi),%rdx <-- decode regs->dx |
40 | * mov 0x38(%rdi),%rcx <-- decode regs->r10 |
41 | * |
42 | * xor %r9d,%r9d <-- clear %r9 |
43 | * xor %r8d,%r8d <-- clear %r8 |
44 | * |
45 | * callq __sys_recvfrom <-- do the actual work in __sys_recvfrom() |
46 | * which takes 6 arguments |
47 | * |
48 | * cltq <-- extend return value to 64-bit |
49 | * retq <-- return |
50 | * |
51 | * This approach avoids leaking random user-provided register content down |
52 | * the call chain. |
53 | */ |
54 | |
55 | /* Mapping of registers to parameters for syscalls on x86-64 and x32 */ |
56 | #define SC_X86_64_REGS_TO_ARGS(x, ...) \ |
57 | __MAP(x,__SC_ARGS \ |
58 | ,,regs->di,,regs->si,,regs->dx \ |
59 | ,,regs->r10,,regs->r8,,regs->r9) \ |
60 | |
61 | /* Mapping of registers to parameters for syscalls on i386 */ |
62 | #define SC_IA32_REGS_TO_ARGS(x, ...) \ |
63 | __MAP(x,__SC_ARGS \ |
64 | ,,(unsigned int)regs->bx,,(unsigned int)regs->cx \ |
65 | ,,(unsigned int)regs->dx,,(unsigned int)regs->si \ |
66 | ,,(unsigned int)regs->di,,(unsigned int)regs->bp) |
67 | |
68 | #define __SYS_STUB0(abi, name) \ |
69 | long __##abi##_##name(const struct pt_regs *regs); \ |
70 | ALLOW_ERROR_INJECTION(__##abi##_##name, ERRNO); \ |
71 | long __##abi##_##name(const struct pt_regs *regs) \ |
72 | __alias(__do_##name); |
73 | |
74 | #define __SYS_STUBx(abi, name, ...) \ |
75 | long __##abi##_##name(const struct pt_regs *regs); \ |
76 | ALLOW_ERROR_INJECTION(__##abi##_##name, ERRNO); \ |
77 | long __##abi##_##name(const struct pt_regs *regs) \ |
78 | { \ |
79 | return __se_##name(__VA_ARGS__); \ |
80 | } |
81 | |
82 | #define __COND_SYSCALL(abi, name) \ |
83 | __weak long __##abi##_##name(const struct pt_regs *__unused); \ |
84 | __weak long __##abi##_##name(const struct pt_regs *__unused) \ |
85 | { \ |
86 | return sys_ni_syscall(); \ |
87 | } |
88 | |
89 | #define __SYS_NI(abi, name) \ |
90 | SYSCALL_ALIAS(__##abi##_##name, sys_ni_posix_timers); |
91 | |
92 | #ifdef CONFIG_X86_64 |
93 | #define __X64_SYS_STUB0(name) \ |
94 | __SYS_STUB0(x64, sys_##name) |
95 | |
96 | #define __X64_SYS_STUBx(x, name, ...) \ |
97 | __SYS_STUBx(x64, sys##name, \ |
98 | SC_X86_64_REGS_TO_ARGS(x, __VA_ARGS__)) |
99 | |
100 | #define __X64_COND_SYSCALL(name) \ |
101 | __COND_SYSCALL(x64, sys_##name) |
102 | |
103 | #define __X64_SYS_NI(name) \ |
104 | __SYS_NI(x64, sys_##name) |
105 | #else /* CONFIG_X86_64 */ |
106 | #define __X64_SYS_STUB0(name) |
107 | #define __X64_SYS_STUBx(x, name, ...) |
108 | #define __X64_COND_SYSCALL(name) |
109 | #define __X64_SYS_NI(name) |
110 | #endif /* CONFIG_X86_64 */ |
111 | |
112 | #if defined(CONFIG_X86_32) || defined(CONFIG_IA32_EMULATION) |
113 | #define __IA32_SYS_STUB0(name) \ |
114 | __SYS_STUB0(ia32, sys_##name) |
115 | |
116 | #define __IA32_SYS_STUBx(x, name, ...) \ |
117 | __SYS_STUBx(ia32, sys##name, \ |
118 | SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__)) |
119 | |
120 | #define __IA32_COND_SYSCALL(name) \ |
121 | __COND_SYSCALL(ia32, sys_##name) |
122 | |
123 | #define __IA32_SYS_NI(name) \ |
124 | __SYS_NI(ia32, sys_##name) |
125 | #else /* CONFIG_X86_32 || CONFIG_IA32_EMULATION */ |
126 | #define __IA32_SYS_STUB0(name) |
127 | #define __IA32_SYS_STUBx(x, name, ...) |
128 | #define __IA32_COND_SYSCALL(name) |
129 | #define __IA32_SYS_NI(name) |
130 | #endif /* CONFIG_X86_32 || CONFIG_IA32_EMULATION */ |
131 | |
132 | #ifdef CONFIG_IA32_EMULATION |
133 | /* |
134 | * For IA32 emulation, we need to handle "compat" syscalls *and* create |
135 | * additional wrappers (aptly named __ia32_sys_xyzzy) which decode the |
136 | * ia32 regs in the proper order for shared or "common" syscalls. As some |
137 | * syscalls may not be implemented, we need to expand COND_SYSCALL in |
138 | * kernel/sys_ni.c and SYS_NI in kernel/time/posix-stubs.c to cover this |
139 | * case as well. |
140 | */ |
141 | #define __IA32_COMPAT_SYS_STUB0(name) \ |
142 | __SYS_STUB0(ia32, compat_sys_##name) |
143 | |
144 | #define __IA32_COMPAT_SYS_STUBx(x, name, ...) \ |
145 | __SYS_STUBx(ia32, compat_sys##name, \ |
146 | SC_IA32_REGS_TO_ARGS(x, __VA_ARGS__)) |
147 | |
148 | #define __IA32_COMPAT_COND_SYSCALL(name) \ |
149 | __COND_SYSCALL(ia32, compat_sys_##name) |
150 | |
151 | #define __IA32_COMPAT_SYS_NI(name) \ |
152 | __SYS_NI(ia32, compat_sys_##name) |
153 | |
154 | #else /* CONFIG_IA32_EMULATION */ |
155 | #define __IA32_COMPAT_SYS_STUB0(name) |
156 | #define __IA32_COMPAT_SYS_STUBx(x, name, ...) |
157 | #define __IA32_COMPAT_COND_SYSCALL(name) |
158 | #define __IA32_COMPAT_SYS_NI(name) |
159 | #endif /* CONFIG_IA32_EMULATION */ |
160 | |
161 | |
162 | #ifdef CONFIG_X86_X32_ABI |
163 | /* |
164 | * For the x32 ABI, we need to create a stub for compat_sys_*() which is aware |
165 | * of the x86-64-style parameter ordering of x32 syscalls. The syscalls common |
166 | * with x86_64 obviously do not need such care. |
167 | */ |
168 | #define __X32_COMPAT_SYS_STUB0(name) \ |
169 | __SYS_STUB0(x64, compat_sys_##name) |
170 | |
171 | #define __X32_COMPAT_SYS_STUBx(x, name, ...) \ |
172 | __SYS_STUBx(x64, compat_sys##name, \ |
173 | SC_X86_64_REGS_TO_ARGS(x, __VA_ARGS__)) |
174 | |
175 | #define __X32_COMPAT_COND_SYSCALL(name) \ |
176 | __COND_SYSCALL(x64, compat_sys_##name) |
177 | |
178 | #define __X32_COMPAT_SYS_NI(name) \ |
179 | __SYS_NI(x64, compat_sys_##name) |
180 | #else /* CONFIG_X86_X32_ABI */ |
181 | #define __X32_COMPAT_SYS_STUB0(name) |
182 | #define __X32_COMPAT_SYS_STUBx(x, name, ...) |
183 | #define __X32_COMPAT_COND_SYSCALL(name) |
184 | #define __X32_COMPAT_SYS_NI(name) |
185 | #endif /* CONFIG_X86_X32_ABI */ |
186 | |
187 | |
188 | #ifdef CONFIG_COMPAT |
189 | /* |
190 | * Compat means IA32_EMULATION and/or X86_X32. As they use a different |
191 | * mapping of registers to parameters, we need to generate stubs for each |
192 | * of them. |
193 | */ |
194 | #define COMPAT_SYSCALL_DEFINE0(name) \ |
195 | static long \ |
196 | __do_compat_sys_##name(const struct pt_regs *__unused); \ |
197 | __IA32_COMPAT_SYS_STUB0(name) \ |
198 | __X32_COMPAT_SYS_STUB0(name) \ |
199 | static long \ |
200 | __do_compat_sys_##name(const struct pt_regs *__unused) |
201 | |
202 | #define COMPAT_SYSCALL_DEFINEx(x, name, ...) \ |
203 | static long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)); \ |
204 | static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__));\ |
205 | __IA32_COMPAT_SYS_STUBx(x, name, __VA_ARGS__) \ |
206 | __X32_COMPAT_SYS_STUBx(x, name, __VA_ARGS__) \ |
207 | static long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)) \ |
208 | { \ |
209 | return __do_compat_sys##name(__MAP(x,__SC_DELOUSE,__VA_ARGS__));\ |
210 | } \ |
211 | static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)) |
212 | |
213 | /* |
214 | * As some compat syscalls may not be implemented, we need to expand |
215 | * COND_SYSCALL_COMPAT in kernel/sys_ni.c and COMPAT_SYS_NI in |
216 | * kernel/time/posix-stubs.c to cover this case as well. |
217 | */ |
218 | #define COND_SYSCALL_COMPAT(name) \ |
219 | __IA32_COMPAT_COND_SYSCALL(name) \ |
220 | __X32_COMPAT_COND_SYSCALL(name) |
221 | |
222 | #define COMPAT_SYS_NI(name) \ |
223 | __IA32_COMPAT_SYS_NI(name) \ |
224 | __X32_COMPAT_SYS_NI(name) |
225 | |
226 | #endif /* CONFIG_COMPAT */ |
227 | |
228 | #define __SYSCALL_DEFINEx(x, name, ...) \ |
229 | static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)); \ |
230 | static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__));\ |
231 | __X64_SYS_STUBx(x, name, __VA_ARGS__) \ |
232 | __IA32_SYS_STUBx(x, name, __VA_ARGS__) \ |
233 | static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)) \ |
234 | { \ |
235 | long ret = __do_sys##name(__MAP(x,__SC_CAST,__VA_ARGS__));\ |
236 | __MAP(x,__SC_TEST,__VA_ARGS__); \ |
237 | __PROTECT(x, ret,__MAP(x,__SC_ARGS,__VA_ARGS__)); \ |
238 | return ret; \ |
239 | } \ |
240 | static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)) |
241 | |
242 | /* |
243 | * As the generic SYSCALL_DEFINE0() macro does not decode any parameters for |
244 | * obvious reasons, and passing struct pt_regs *regs to it in %rdi does not |
245 | * hurt, we only need to re-define it here to keep the naming congruent to |
246 | * SYSCALL_DEFINEx() -- which is essential for the COND_SYSCALL() and SYS_NI() |
247 | * macros to work correctly. |
248 | */ |
249 | #define SYSCALL_DEFINE0(sname) \ |
250 | SYSCALL_METADATA(_##sname, 0); \ |
251 | static long __do_sys_##sname(const struct pt_regs *__unused); \ |
252 | __X64_SYS_STUB0(sname) \ |
253 | __IA32_SYS_STUB0(sname) \ |
254 | static long __do_sys_##sname(const struct pt_regs *__unused) |
255 | |
256 | #define COND_SYSCALL(name) \ |
257 | __X64_COND_SYSCALL(name) \ |
258 | __IA32_COND_SYSCALL(name) |
259 | |
260 | #define SYS_NI(name) \ |
261 | __X64_SYS_NI(name) \ |
262 | __IA32_SYS_NI(name) |
263 | |
264 | |
265 | /* |
266 | * For VSYSCALLS, we need to declare these three syscalls with the new |
267 | * pt_regs-based calling convention for in-kernel use. |
268 | */ |
269 | long __x64_sys_getcpu(const struct pt_regs *regs); |
270 | long __x64_sys_gettimeofday(const struct pt_regs *regs); |
271 | long __x64_sys_time(const struct pt_regs *regs); |
272 | |
273 | #endif /* _ASM_X86_SYSCALL_WRAPPER_H */ |
274 | |