Commit | Line | Data |
---|---|---|
21b32bbf | 1 | /* |
21b32bbf IM |
2 | * Stack trace management functions |
3 | * | |
8f47e163 | 4 | * Copyright (C) 2006-2009 Red Hat, Inc., Ingo Molnar <mingo@redhat.com> |
21b32bbf IM |
5 | */ |
6 | #include <linux/sched.h> | |
b17b0153 | 7 | #include <linux/sched/debug.h> |
68db0cf1 | 8 | #include <linux/sched/task_stack.h> |
21b32bbf | 9 | #include <linux/stacktrace.h> |
186f4360 | 10 | #include <linux/export.h> |
02b67518 | 11 | #include <linux/uaccess.h> |
c0b766f1 | 12 | #include <asm/stacktrace.h> |
49a612c6 | 13 | #include <asm/unwind.h> |
21b32bbf | 14 | |
49a612c6 JP |
15 | static int save_stack_address(struct stack_trace *trace, unsigned long addr, |
16 | bool nosched) | |
21b32bbf | 17 | { |
018378c5 | 18 | if (nosched && in_sched_functions(addr)) |
568b329a | 19 | return 0; |
49a612c6 | 20 | |
c0b766f1 AK |
21 | if (trace->skip > 0) { |
22 | trace->skip--; | |
568b329a | 23 | return 0; |
21b32bbf | 24 | } |
21b32bbf | 25 | |
49a612c6 JP |
26 | if (trace->nr_entries >= trace->max_entries) |
27 | return -1; | |
28 | ||
29 | trace->entries[trace->nr_entries++] = addr; | |
30 | return 0; | |
018378c5 ON |
31 | } |
32 | ||
77072f09 | 33 | static void noinline __save_stack_trace(struct stack_trace *trace, |
49a612c6 JP |
34 | struct task_struct *task, struct pt_regs *regs, |
35 | bool nosched) | |
9745512c | 36 | { |
49a612c6 JP |
37 | struct unwind_state state; |
38 | unsigned long addr; | |
9745512c | 39 | |
49a612c6 JP |
40 | if (regs) |
41 | save_stack_address(trace, regs->ip, nosched); | |
21b32bbf | 42 | |
49a612c6 JP |
43 | for (unwind_start(&state, task, regs, NULL); !unwind_done(&state); |
44 | unwind_next_frame(&state)) { | |
45 | addr = unwind_get_return_address(&state); | |
46 | if (!addr || save_stack_address(trace, addr, nosched)) | |
47 | break; | |
48 | } | |
49 | ||
50 | if (trace->nr_entries < trace->max_entries) | |
51 | trace->entries[trace->nr_entries++] = ULONG_MAX; | |
52 | } | |
9745512c | 53 | |
21b32bbf IM |
54 | /* |
55 | * Save stack-backtrace addresses into a stack_trace buffer. | |
21b32bbf | 56 | */ |
ab1b6f03 | 57 | void save_stack_trace(struct stack_trace *trace) |
21b32bbf | 58 | { |
77072f09 | 59 | trace->skip++; |
49a612c6 | 60 | __save_stack_trace(trace, current, NULL, false); |
21b32bbf | 61 | } |
8594698e | 62 | EXPORT_SYMBOL_GPL(save_stack_trace); |
9745512c | 63 | |
39581062 | 64 | void save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace) |
acc6be54 | 65 | { |
49a612c6 | 66 | __save_stack_trace(trace, current, regs, false); |
acc6be54 VN |
67 | } |
68 | ||
9745512c AV |
69 | void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace) |
70 | { | |
1959a601 AL |
71 | if (!try_get_task_stack(tsk)) |
72 | return; | |
73 | ||
77072f09 VB |
74 | if (tsk == current) |
75 | trace->skip++; | |
49a612c6 | 76 | __save_stack_trace(trace, tsk, NULL, true); |
1959a601 AL |
77 | |
78 | put_task_stack(tsk); | |
9745512c | 79 | } |
8594698e | 80 | EXPORT_SYMBOL_GPL(save_stack_trace_tsk); |
02b67518 | 81 | |
af085d90 JP |
82 | #ifdef CONFIG_HAVE_RELIABLE_STACKTRACE |
83 | ||
84 | #define STACKTRACE_DUMP_ONCE(task) ({ \ | |
85 | static bool __section(.data.unlikely) __dumped; \ | |
86 | \ | |
87 | if (!__dumped) { \ | |
88 | __dumped = true; \ | |
89 | WARN_ON(1); \ | |
90 | show_stack(task, NULL); \ | |
91 | } \ | |
92 | }) | |
93 | ||
77072f09 VB |
94 | static int __always_inline |
95 | __save_stack_trace_reliable(struct stack_trace *trace, | |
96 | struct task_struct *task) | |
af085d90 JP |
97 | { |
98 | struct unwind_state state; | |
99 | struct pt_regs *regs; | |
100 | unsigned long addr; | |
101 | ||
102 | for (unwind_start(&state, task, NULL, NULL); !unwind_done(&state); | |
103 | unwind_next_frame(&state)) { | |
104 | ||
a9cdbe72 | 105 | regs = unwind_get_entry_regs(&state, NULL); |
af085d90 JP |
106 | if (regs) { |
107 | /* | |
108 | * Kernel mode registers on the stack indicate an | |
109 | * in-kernel interrupt or exception (e.g., preemption | |
110 | * or a page fault), which can make frame pointers | |
111 | * unreliable. | |
112 | */ | |
113 | if (!user_mode(regs)) | |
114 | return -EINVAL; | |
115 | ||
116 | /* | |
117 | * The last frame contains the user mode syscall | |
118 | * pt_regs. Skip it and finish the unwind. | |
119 | */ | |
120 | unwind_next_frame(&state); | |
121 | if (!unwind_done(&state)) { | |
122 | STACKTRACE_DUMP_ONCE(task); | |
123 | return -EINVAL; | |
124 | } | |
125 | break; | |
126 | } | |
127 | ||
128 | addr = unwind_get_return_address(&state); | |
129 | ||
130 | /* | |
131 | * A NULL or invalid return address probably means there's some | |
132 | * generated code which __kernel_text_address() doesn't know | |
133 | * about. | |
134 | */ | |
135 | if (!addr) { | |
136 | STACKTRACE_DUMP_ONCE(task); | |
137 | return -EINVAL; | |
138 | } | |
139 | ||
140 | if (save_stack_address(trace, addr, false)) | |
141 | return -EINVAL; | |
142 | } | |
143 | ||
144 | /* Check for stack corruption */ | |
145 | if (unwind_error(&state)) { | |
146 | STACKTRACE_DUMP_ONCE(task); | |
147 | return -EINVAL; | |
148 | } | |
149 | ||
150 | if (trace->nr_entries < trace->max_entries) | |
151 | trace->entries[trace->nr_entries++] = ULONG_MAX; | |
152 | ||
153 | return 0; | |
154 | } | |
155 | ||
156 | /* | |
157 | * This function returns an error if it detects any unreliable features of the | |
158 | * stack. Otherwise it guarantees that the stack trace is reliable. | |
159 | * | |
160 | * If the task is not 'current', the caller *must* ensure the task is inactive. | |
161 | */ | |
162 | int save_stack_trace_tsk_reliable(struct task_struct *tsk, | |
163 | struct stack_trace *trace) | |
164 | { | |
165 | int ret; | |
166 | ||
6454b3bd JP |
167 | /* |
168 | * If the task doesn't have a stack (e.g., a zombie), the stack is | |
169 | * "reliably" empty. | |
170 | */ | |
af085d90 | 171 | if (!try_get_task_stack(tsk)) |
6454b3bd | 172 | return 0; |
af085d90 JP |
173 | |
174 | ret = __save_stack_trace_reliable(trace, tsk); | |
175 | ||
176 | put_task_stack(tsk); | |
177 | ||
178 | return ret; | |
179 | } | |
180 | #endif /* CONFIG_HAVE_RELIABLE_STACKTRACE */ | |
181 | ||
02b67518 TE |
182 | /* Userspace stacktrace - based on kernel/trace/trace_sysprof.c */ |
183 | ||
c9cf4dbb | 184 | struct stack_frame_user { |
02b67518 | 185 | const void __user *next_fp; |
8d7c6a96 | 186 | unsigned long ret_addr; |
02b67518 TE |
187 | }; |
188 | ||
c9cf4dbb FW |
189 | static int |
190 | copy_stack_frame(const void __user *fp, struct stack_frame_user *frame) | |
02b67518 TE |
191 | { |
192 | int ret; | |
193 | ||
194 | if (!access_ok(VERIFY_READ, fp, sizeof(*frame))) | |
195 | return 0; | |
196 | ||
197 | ret = 1; | |
198 | pagefault_disable(); | |
199 | if (__copy_from_user_inatomic(frame, fp, sizeof(*frame))) | |
200 | ret = 0; | |
201 | pagefault_enable(); | |
202 | ||
203 | return ret; | |
204 | } | |
205 | ||
8d7c6a96 TE |
206 | static inline void __save_stack_trace_user(struct stack_trace *trace) |
207 | { | |
208 | const struct pt_regs *regs = task_pt_regs(current); | |
209 | const void __user *fp = (const void __user *)regs->bp; | |
210 | ||
211 | if (trace->nr_entries < trace->max_entries) | |
212 | trace->entries[trace->nr_entries++] = regs->ip; | |
213 | ||
214 | while (trace->nr_entries < trace->max_entries) { | |
c9cf4dbb | 215 | struct stack_frame_user frame; |
8d7c6a96 TE |
216 | |
217 | frame.next_fp = NULL; | |
218 | frame.ret_addr = 0; | |
219 | if (!copy_stack_frame(fp, &frame)) | |
220 | break; | |
221 | if ((unsigned long)fp < regs->sp) | |
222 | break; | |
223 | if (frame.ret_addr) { | |
224 | trace->entries[trace->nr_entries++] = | |
225 | frame.ret_addr; | |
226 | } | |
227 | if (fp == frame.next_fp) | |
228 | break; | |
229 | fp = frame.next_fp; | |
230 | } | |
231 | } | |
232 | ||
02b67518 TE |
233 | void save_stack_trace_user(struct stack_trace *trace) |
234 | { | |
235 | /* | |
236 | * Trace user stack if we are not a kernel thread | |
237 | */ | |
238 | if (current->mm) { | |
8d7c6a96 | 239 | __save_stack_trace_user(trace); |
02b67518 TE |
240 | } |
241 | if (trace->nr_entries < trace->max_entries) | |
242 | trace->entries[trace->nr_entries++] = ULONG_MAX; | |
243 | } |