tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Stack trace management functions
4 *
5 * Copyright IBM Corp. 2006
6 */
7
8#include <linux/perf_event.h>
9#include <linux/stacktrace.h>
10#include <linux/uaccess.h>
11#include <linux/compat.h>
12#include <asm/asm-offsets.h>
13#include <asm/stacktrace.h>
14#include <asm/unwind.h>
15#include <asm/kprobes.h>
16#include <asm/ptrace.h>
17
18void arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie,
19 struct task_struct *task, struct pt_regs *regs)
20{
21 struct unwind_state state;
22 unsigned long addr;
23
24 unwind_for_each_frame(&state, task, regs, 0) {
25 addr = unwind_get_return_address(&state);
26 if (!addr || !consume_entry(cookie, addr))
27 break;
28 }
29}
30
31int arch_stack_walk_reliable(stack_trace_consume_fn consume_entry,
32 void *cookie, struct task_struct *task)
33{
34 struct unwind_state state;
35 unsigned long addr;
36
37 unwind_for_each_frame(&state, task, NULL, 0) {
38 if (state.stack_info.type != STACK_TYPE_TASK)
39 return -EINVAL;
40
41 if (state.regs)
42 return -EINVAL;
43
44 addr = unwind_get_return_address(&state);
45 if (!addr)
46 return -EINVAL;
47
48#ifdef CONFIG_RETHOOK
49 /*
50 * Mark stacktraces with krethook functions on them
51 * as unreliable.
52 */
53 if (state.ip == (unsigned long)arch_rethook_trampoline)
54 return -EINVAL;
55#endif
56
57 if (!consume_entry(cookie, addr))
58 return -EINVAL;
59 }
60
61 /* Check for stack corruption */
62 if (unwind_error(&state))
63 return -EINVAL;
64 return 0;
65}
66
67static inline bool store_ip(stack_trace_consume_fn consume_entry, void *cookie,
68 struct perf_callchain_entry_ctx *entry, bool perf,
69 unsigned long ip)
70{
71#ifdef CONFIG_PERF_EVENTS
72 if (perf) {
73 if (perf_callchain_store(entry, ip))
74 return false;
75 return true;
76 }
77#endif
78 return consume_entry(cookie, ip);
79}
80
81static inline bool ip_invalid(unsigned long ip)
82{
83 /*
84 * Perform some basic checks if an instruction address taken
85 * from unreliable source is invalid.
86 */
87 if (ip & 1)
88 return true;
89 if (ip < mmap_min_addr)
90 return true;
91 if (ip >= current->mm->context.asce_limit)
92 return true;
93 return false;
94}
95
96static inline bool ip_within_vdso(unsigned long ip)
97{
98 return in_range(ip, current->mm->context.vdso_base, vdso_text_size());
99}
100
101void arch_stack_walk_user_common(stack_trace_consume_fn consume_entry, void *cookie,
102 struct perf_callchain_entry_ctx *entry,
103 const struct pt_regs *regs, bool perf)
104{
105 struct stack_frame_vdso_wrapper __user *sf_vdso;
106 struct stack_frame_user __user *sf;
107 unsigned long ip, sp;
108 bool first = true;
109
110 if (is_compat_task())
111 return;
112 if (!current->mm)
113 return;
114 ip = instruction_pointer(regs);
115 if (!store_ip(consume_entry, cookie, entry, perf, ip))
116 return;
117 sf = (void __user *)user_stack_pointer(regs);
118 pagefault_disable();
119 while (1) {
120 if (__get_user(sp, &sf->back_chain))
121 break;
122 /*
123 * VDSO entry code has a non-standard stack frame layout.
124 * See VDSO user wrapper code for details.
125 */
126 if (!sp && ip_within_vdso(ip)) {
127 sf_vdso = (void __user *)sf;
128 if (__get_user(ip, &sf_vdso->return_address))
129 break;
130 sp = (unsigned long)sf + STACK_FRAME_VDSO_OVERHEAD;
131 sf = (void __user *)sp;
132 if (__get_user(sp, &sf->back_chain))
133 break;
134 } else {
135 sf = (void __user *)sp;
136 if (__get_user(ip, &sf->gprs[8]))
137 break;
138 }
139 /* Sanity check: ABI requires SP to be 8 byte aligned. */
140 if (sp & 0x7)
141 break;
142 if (ip_invalid(ip)) {
143 /*
144 * If the instruction address is invalid, and this
145 * is the first stack frame, assume r14 has not
146 * been written to the stack yet. Otherwise exit.
147 */
148 if (!first)
149 break;
150 ip = regs->gprs[14];
151 if (ip_invalid(ip))
152 break;
153 }
154 if (!store_ip(consume_entry, cookie, entry, perf, ip))
155 break;
156 first = false;
157 }
158 pagefault_enable();
159}
160
161void arch_stack_walk_user(stack_trace_consume_fn consume_entry, void *cookie,
162 const struct pt_regs *regs)
163{
164 arch_stack_walk_user_common(consume_entry, cookie, NULL, regs, false);
165}