1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #ifndef _ASM_X86_PTRACE_H |
3 | #define _ASM_X86_PTRACE_H |
4 | |
5 | #include <asm/segment.h> |
6 | #include <asm/page_types.h> |
7 | #include <uapi/asm/ptrace.h> |
8 | |
9 | #ifndef __ASSEMBLY__ |
10 | #ifdef __i386__ |
11 | |
12 | struct pt_regs { |
13 | /* |
14 | * NB: 32-bit x86 CPUs are inconsistent as what happens in the |
15 | * following cases (where %seg represents a segment register): |
16 | * |
17 | * - pushl %seg: some do a 16-bit write and leave the high |
18 | * bits alone |
19 | * - movl %seg, [mem]: some do a 16-bit write despite the movl |
20 | * - IDT entry: some (e.g. 486) will leave the high bits of CS |
21 | * and (if applicable) SS undefined. |
22 | * |
23 | * Fortunately, x86-32 doesn't read the high bits on POP or IRET, |
24 | * so we can just treat all of the segment registers as 16-bit |
25 | * values. |
26 | */ |
27 | unsigned long bx; |
28 | unsigned long cx; |
29 | unsigned long dx; |
30 | unsigned long si; |
31 | unsigned long di; |
32 | unsigned long bp; |
33 | unsigned long ax; |
34 | unsigned short ds; |
35 | unsigned short __dsh; |
36 | unsigned short es; |
37 | unsigned short __esh; |
38 | unsigned short fs; |
39 | unsigned short __fsh; |
40 | /* |
41 | * On interrupt, gs and __gsh store the vector number. They never |
42 | * store gs any more. |
43 | */ |
44 | unsigned short gs; |
45 | unsigned short __gsh; |
46 | /* On interrupt, this is the error code. */ |
47 | unsigned long orig_ax; |
48 | unsigned long ip; |
49 | unsigned short cs; |
50 | unsigned short __csh; |
51 | unsigned long flags; |
52 | unsigned long sp; |
53 | unsigned short ss; |
54 | unsigned short __ssh; |
55 | }; |
56 | |
57 | #else /* __i386__ */ |
58 | |
59 | struct pt_regs { |
60 | /* |
61 | * C ABI says these regs are callee-preserved. They aren't saved on kernel entry |
62 | * unless syscall needs a complete, fully filled "struct pt_regs". |
63 | */ |
64 | unsigned long r15; |
65 | unsigned long r14; |
66 | unsigned long r13; |
67 | unsigned long r12; |
68 | unsigned long bp; |
69 | unsigned long bx; |
70 | /* These regs are callee-clobbered. Always saved on kernel entry. */ |
71 | unsigned long r11; |
72 | unsigned long r10; |
73 | unsigned long r9; |
74 | unsigned long r8; |
75 | unsigned long ax; |
76 | unsigned long cx; |
77 | unsigned long dx; |
78 | unsigned long si; |
79 | unsigned long di; |
80 | /* |
81 | * On syscall entry, this is syscall#. On CPU exception, this is error code. |
82 | * On hw interrupt, it's IRQ number: |
83 | */ |
84 | unsigned long orig_ax; |
85 | /* Return frame for iretq */ |
86 | unsigned long ip; |
87 | unsigned long cs; |
88 | unsigned long flags; |
89 | unsigned long sp; |
90 | unsigned long ss; |
91 | /* top of stack page */ |
92 | }; |
93 | |
94 | #endif /* !__i386__ */ |
95 | |
96 | #ifdef CONFIG_PARAVIRT |
97 | #include <asm/paravirt_types.h> |
98 | #endif |
99 | |
100 | #include <asm/proto.h> |
101 | |
102 | struct cpuinfo_x86; |
103 | struct task_struct; |
104 | |
105 | extern unsigned long profile_pc(struct pt_regs *regs); |
106 | |
107 | extern unsigned long |
108 | convert_ip_to_linear(struct task_struct *child, struct pt_regs *regs); |
109 | extern void send_sigtrap(struct pt_regs *regs, int error_code, int si_code); |
110 | |
111 | |
112 | static inline unsigned long regs_return_value(struct pt_regs *regs) |
113 | { |
114 | return regs->ax; |
115 | } |
116 | |
117 | static inline void regs_set_return_value(struct pt_regs *regs, unsigned long rc) |
118 | { |
119 | regs->ax = rc; |
120 | } |
121 | |
122 | /* |
123 | * user_mode(regs) determines whether a register set came from user |
124 | * mode. On x86_32, this is true if V8086 mode was enabled OR if the |
125 | * register set was from protected mode with RPL-3 CS value. This |
126 | * tricky test checks that with one comparison. |
127 | * |
128 | * On x86_64, vm86 mode is mercifully nonexistent, and we don't need |
129 | * the extra check. |
130 | */ |
131 | static __always_inline int user_mode(struct pt_regs *regs) |
132 | { |
133 | #ifdef CONFIG_X86_32 |
134 | return ((regs->cs & SEGMENT_RPL_MASK) | (regs->flags & X86_VM_MASK)) >= USER_RPL; |
135 | #else |
136 | return !!(regs->cs & 3); |
137 | #endif |
138 | } |
139 | |
140 | static __always_inline int v8086_mode(struct pt_regs *regs) |
141 | { |
142 | #ifdef CONFIG_X86_32 |
143 | return (regs->flags & X86_VM_MASK); |
144 | #else |
145 | return 0; /* No V86 mode support in long mode */ |
146 | #endif |
147 | } |
148 | |
149 | static inline bool user_64bit_mode(struct pt_regs *regs) |
150 | { |
151 | #ifdef CONFIG_X86_64 |
152 | #ifndef CONFIG_PARAVIRT_XXL |
153 | /* |
154 | * On non-paravirt systems, this is the only long mode CPL 3 |
155 | * selector. We do not allow long mode selectors in the LDT. |
156 | */ |
157 | return regs->cs == __USER_CS; |
158 | #else |
159 | /* Headers are too twisted for this to go in paravirt.h. */ |
160 | return regs->cs == __USER_CS || regs->cs == pv_info.extra_user_64bit_cs; |
161 | #endif |
162 | #else /* !CONFIG_X86_64 */ |
163 | return false; |
164 | #endif |
165 | } |
166 | |
167 | /* |
168 | * Determine whether the register set came from any context that is running in |
169 | * 64-bit mode. |
170 | */ |
171 | static inline bool any_64bit_mode(struct pt_regs *regs) |
172 | { |
173 | #ifdef CONFIG_X86_64 |
174 | return !user_mode(regs) || user_64bit_mode(regs); |
175 | #else |
176 | return false; |
177 | #endif |
178 | } |
179 | |
180 | #ifdef CONFIG_X86_64 |
181 | #define current_user_stack_pointer() current_pt_regs()->sp |
182 | #define compat_user_stack_pointer() current_pt_regs()->sp |
183 | |
184 | static __always_inline bool ip_within_syscall_gap(struct pt_regs *regs) |
185 | { |
186 | bool ret = (regs->ip >= (unsigned long)entry_SYSCALL_64 && |
187 | regs->ip < (unsigned long)entry_SYSCALL_64_safe_stack); |
188 | |
189 | ret = ret || (regs->ip >= (unsigned long)entry_SYSRETQ_unsafe_stack && |
190 | regs->ip < (unsigned long)entry_SYSRETQ_end); |
191 | #ifdef CONFIG_IA32_EMULATION |
192 | ret = ret || (regs->ip >= (unsigned long)entry_SYSCALL_compat && |
193 | regs->ip < (unsigned long)entry_SYSCALL_compat_safe_stack); |
194 | ret = ret || (regs->ip >= (unsigned long)entry_SYSRETL_compat_unsafe_stack && |
195 | regs->ip < (unsigned long)entry_SYSRETL_compat_end); |
196 | #endif |
197 | |
198 | return ret; |
199 | } |
200 | #endif |
201 | |
202 | static inline unsigned long kernel_stack_pointer(struct pt_regs *regs) |
203 | { |
204 | return regs->sp; |
205 | } |
206 | |
207 | static inline unsigned long instruction_pointer(struct pt_regs *regs) |
208 | { |
209 | return regs->ip; |
210 | } |
211 | |
212 | static inline void instruction_pointer_set(struct pt_regs *regs, |
213 | unsigned long val) |
214 | { |
215 | regs->ip = val; |
216 | } |
217 | |
218 | static inline unsigned long frame_pointer(struct pt_regs *regs) |
219 | { |
220 | return regs->bp; |
221 | } |
222 | |
223 | static inline unsigned long user_stack_pointer(struct pt_regs *regs) |
224 | { |
225 | return regs->sp; |
226 | } |
227 | |
228 | static inline void user_stack_pointer_set(struct pt_regs *regs, |
229 | unsigned long val) |
230 | { |
231 | regs->sp = val; |
232 | } |
233 | |
234 | static __always_inline bool regs_irqs_disabled(struct pt_regs *regs) |
235 | { |
236 | return !(regs->flags & X86_EFLAGS_IF); |
237 | } |
238 | |
239 | /* Query offset/name of register from its name/offset */ |
240 | extern int regs_query_register_offset(const char *name); |
241 | extern const char *regs_query_register_name(unsigned int offset); |
242 | #define MAX_REG_OFFSET (offsetof(struct pt_regs, ss)) |
243 | |
244 | /** |
245 | * regs_get_register() - get register value from its offset |
246 | * @regs: pt_regs from which register value is gotten. |
247 | * @offset: offset number of the register. |
248 | * |
249 | * regs_get_register returns the value of a register. The @offset is the |
250 | * offset of the register in struct pt_regs address which specified by @regs. |
251 | * If @offset is bigger than MAX_REG_OFFSET, this returns 0. |
252 | */ |
253 | static inline unsigned long regs_get_register(struct pt_regs *regs, |
254 | unsigned int offset) |
255 | { |
256 | if (unlikely(offset > MAX_REG_OFFSET)) |
257 | return 0; |
258 | #ifdef CONFIG_X86_32 |
259 | /* The selector fields are 16-bit. */ |
260 | if (offset == offsetof(struct pt_regs, cs) || |
261 | offset == offsetof(struct pt_regs, ss) || |
262 | offset == offsetof(struct pt_regs, ds) || |
263 | offset == offsetof(struct pt_regs, es) || |
264 | offset == offsetof(struct pt_regs, fs) || |
265 | offset == offsetof(struct pt_regs, gs)) { |
266 | return *(u16 *)((unsigned long)regs + offset); |
267 | |
268 | } |
269 | #endif |
270 | return *(unsigned long *)((unsigned long)regs + offset); |
271 | } |
272 | |
273 | /** |
274 | * regs_within_kernel_stack() - check the address in the stack |
275 | * @regs: pt_regs which contains kernel stack pointer. |
276 | * @addr: address which is checked. |
277 | * |
278 | * regs_within_kernel_stack() checks @addr is within the kernel stack page(s). |
279 | * If @addr is within the kernel stack, it returns true. If not, returns false. |
280 | */ |
281 | static inline int regs_within_kernel_stack(struct pt_regs *regs, |
282 | unsigned long addr) |
283 | { |
284 | return ((addr & ~(THREAD_SIZE - 1)) == (regs->sp & ~(THREAD_SIZE - 1))); |
285 | } |
286 | |
287 | /** |
288 | * regs_get_kernel_stack_nth_addr() - get the address of the Nth entry on stack |
289 | * @regs: pt_regs which contains kernel stack pointer. |
290 | * @n: stack entry number. |
291 | * |
292 | * regs_get_kernel_stack_nth() returns the address of the @n th entry of the |
293 | * kernel stack which is specified by @regs. If the @n th entry is NOT in |
294 | * the kernel stack, this returns NULL. |
295 | */ |
296 | static inline unsigned long *regs_get_kernel_stack_nth_addr(struct pt_regs *regs, unsigned int n) |
297 | { |
298 | unsigned long *addr = (unsigned long *)regs->sp; |
299 | |
300 | addr += n; |
301 | if (regs_within_kernel_stack(regs, addr: (unsigned long)addr)) |
302 | return addr; |
303 | else |
304 | return NULL; |
305 | } |
306 | |
307 | /* To avoid include hell, we can't include uaccess.h */ |
308 | extern long copy_from_kernel_nofault(void *dst, const void *src, size_t size); |
309 | |
310 | /** |
311 | * regs_get_kernel_stack_nth() - get Nth entry of the stack |
312 | * @regs: pt_regs which contains kernel stack pointer. |
313 | * @n: stack entry number. |
314 | * |
315 | * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which |
316 | * is specified by @regs. If the @n th entry is NOT in the kernel stack |
317 | * this returns 0. |
318 | */ |
319 | static inline unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, |
320 | unsigned int n) |
321 | { |
322 | unsigned long *addr; |
323 | unsigned long val; |
324 | long ret; |
325 | |
326 | addr = regs_get_kernel_stack_nth_addr(regs, n); |
327 | if (addr) { |
328 | ret = copy_from_kernel_nofault(dst: &val, src: addr, size: sizeof(val)); |
329 | if (!ret) |
330 | return val; |
331 | } |
332 | return 0; |
333 | } |
334 | |
335 | /** |
336 | * regs_get_kernel_argument() - get Nth function argument in kernel |
337 | * @regs: pt_regs of that context |
338 | * @n: function argument number (start from 0) |
339 | * |
340 | * regs_get_argument() returns @n th argument of the function call. |
341 | * Note that this chooses most probably assignment, in some case |
342 | * it can be incorrect. |
343 | * This is expected to be called from kprobes or ftrace with regs |
344 | * where the top of stack is the return address. |
345 | */ |
346 | static inline unsigned long regs_get_kernel_argument(struct pt_regs *regs, |
347 | unsigned int n) |
348 | { |
349 | static const unsigned int argument_offs[] = { |
350 | #ifdef __i386__ |
351 | offsetof(struct pt_regs, ax), |
352 | offsetof(struct pt_regs, dx), |
353 | offsetof(struct pt_regs, cx), |
354 | #define NR_REG_ARGUMENTS 3 |
355 | #else |
356 | offsetof(struct pt_regs, di), |
357 | offsetof(struct pt_regs, si), |
358 | offsetof(struct pt_regs, dx), |
359 | offsetof(struct pt_regs, cx), |
360 | offsetof(struct pt_regs, r8), |
361 | offsetof(struct pt_regs, r9), |
362 | #define NR_REG_ARGUMENTS 6 |
363 | #endif |
364 | }; |
365 | |
366 | if (n >= NR_REG_ARGUMENTS) { |
367 | n -= NR_REG_ARGUMENTS - 1; |
368 | return regs_get_kernel_stack_nth(regs, n); |
369 | } else |
370 | return regs_get_register(regs, offset: argument_offs[n]); |
371 | } |
372 | |
373 | #define arch_has_single_step() (1) |
374 | #ifdef CONFIG_X86_DEBUGCTLMSR |
375 | #define arch_has_block_step() (1) |
376 | #else |
377 | #define arch_has_block_step() (boot_cpu_data.x86 >= 6) |
378 | #endif |
379 | |
380 | #define ARCH_HAS_USER_SINGLE_STEP_REPORT |
381 | |
382 | struct user_desc; |
383 | extern int do_get_thread_area(struct task_struct *p, int idx, |
384 | struct user_desc __user *info); |
385 | extern int do_set_thread_area(struct task_struct *p, int idx, |
386 | struct user_desc __user *info, int can_allocate); |
387 | |
388 | #ifdef CONFIG_X86_64 |
389 | # define do_set_thread_area_64(p, s, t) do_arch_prctl_64(p, s, t) |
390 | #else |
391 | # define do_set_thread_area_64(p, s, t) (0) |
392 | #endif |
393 | |
394 | #endif /* !__ASSEMBLY__ */ |
395 | #endif /* _ASM_X86_PTRACE_H */ |
396 | |