1
2
3
4
5
6
7
8
9#include <linux/sched/task_stack.h>
10#include <linux/sched/debug.h>
11#include <linux/sched.h>
12#include <linux/kernel.h>
13#include <linux/export.h>
14#include <linux/kallsyms.h>
15#include <linux/stacktrace.h>
16
17
18
19
20
21
22
23void stack_trace_print(unsigned long *entries, unsigned int nr_entries,
24 int spaces)
25{
26 unsigned int i;
27
28 if (WARN_ON(!entries))
29 return;
30
31 for (i = 0; i < nr_entries; i++)
32 printk("%*c%pS\n", 1 + spaces, ' ', (void *)entries[i]);
33}
34EXPORT_SYMBOL_GPL(stack_trace_print);
35
36
37
38
39
40
41
42
43
44
45
46int stack_trace_snprint(char *buf, size_t size, unsigned long *entries,
47 unsigned int nr_entries, int spaces)
48{
49 unsigned int generated, i, total = 0;
50
51 if (WARN_ON(!entries))
52 return 0;
53
54 for (i = 0; i < nr_entries && size; i++) {
55 generated = snprintf(buf, size, "%*c%pS\n", 1 + spaces, ' ',
56 (void *)entries[i]);
57
58 total += generated;
59 if (generated >= size) {
60 buf += size;
61 size = 0;
62 } else {
63 buf += generated;
64 size -= generated;
65 }
66 }
67
68 return total;
69}
70EXPORT_SYMBOL_GPL(stack_trace_snprint);
71
72#ifdef CONFIG_ARCH_STACKWALK
73
74struct stacktrace_cookie {
75 unsigned long *store;
76 unsigned int size;
77 unsigned int skip;
78 unsigned int len;
79};
80
81static bool stack_trace_consume_entry(void *cookie, unsigned long addr,
82 bool reliable)
83{
84 struct stacktrace_cookie *c = cookie;
85
86 if (c->len >= c->size)
87 return false;
88
89 if (c->skip > 0) {
90 c->skip--;
91 return true;
92 }
93 c->store[c->len++] = addr;
94 return c->len < c->size;
95}
96
97static bool stack_trace_consume_entry_nosched(void *cookie, unsigned long addr,
98 bool reliable)
99{
100 if (in_sched_functions(addr))
101 return true;
102 return stack_trace_consume_entry(cookie, addr, reliable);
103}
104
105
106
107
108
109
110
111
112
113unsigned int stack_trace_save(unsigned long *store, unsigned int size,
114 unsigned int skipnr)
115{
116 stack_trace_consume_fn consume_entry = stack_trace_consume_entry;
117 struct stacktrace_cookie c = {
118 .store = store,
119 .size = size,
120 .skip = skipnr + 1,
121 };
122
123 arch_stack_walk(consume_entry, &c, current, NULL);
124 return c.len;
125}
126EXPORT_SYMBOL_GPL(stack_trace_save);
127
128
129
130
131
132
133
134
135
136
137unsigned int stack_trace_save_tsk(struct task_struct *tsk, unsigned long *store,
138 unsigned int size, unsigned int skipnr)
139{
140 stack_trace_consume_fn consume_entry = stack_trace_consume_entry_nosched;
141 struct stacktrace_cookie c = {
142 .store = store,
143 .size = size,
144 .skip = skipnr + 1,
145 };
146
147 if (!try_get_task_stack(tsk))
148 return 0;
149
150 arch_stack_walk(consume_entry, &c, tsk, NULL);
151 put_task_stack(tsk);
152 return c.len;
153}
154
155
156
157
158
159
160
161
162
163
164unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store,
165 unsigned int size, unsigned int skipnr)
166{
167 stack_trace_consume_fn consume_entry = stack_trace_consume_entry;
168 struct stacktrace_cookie c = {
169 .store = store,
170 .size = size,
171 .skip = skipnr,
172 };
173
174 arch_stack_walk(consume_entry, &c, current, regs);
175 return c.len;
176}
177
178#ifdef CONFIG_HAVE_RELIABLE_STACKTRACE
179
180
181
182
183
184
185
186
187
188
189
190
191int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store,
192 unsigned int size)
193{
194 stack_trace_consume_fn consume_entry = stack_trace_consume_entry;
195 struct stacktrace_cookie c = {
196 .store = store,
197 .size = size,
198 };
199 int ret;
200
201
202
203
204
205 if (!try_get_task_stack(tsk))
206 return 0;
207
208 ret = arch_stack_walk_reliable(consume_entry, &c, tsk);
209 put_task_stack(tsk);
210 return ret ? ret : c.len;
211}
212#endif
213
214#ifdef CONFIG_USER_STACKTRACE_SUPPORT
215
216
217
218
219
220
221
222unsigned int stack_trace_save_user(unsigned long *store, unsigned int size)
223{
224 stack_trace_consume_fn consume_entry = stack_trace_consume_entry;
225 struct stacktrace_cookie c = {
226 .store = store,
227 .size = size,
228 };
229 mm_segment_t fs;
230
231
232 if (current->flags & PF_KTHREAD)
233 return 0;
234
235 fs = get_fs();
236 set_fs(USER_DS);
237 arch_stack_walk_user(consume_entry, &c, task_pt_regs(current));
238 set_fs(fs);
239
240 return c.len;
241}
242#endif
243
244#else
245
246
247
248
249
250
251__weak void
252save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
253{
254 WARN_ONCE(1, KERN_INFO "save_stack_trace_tsk() not implemented yet.\n");
255}
256
257__weak void
258save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace)
259{
260 WARN_ONCE(1, KERN_INFO "save_stack_trace_regs() not implemented yet.\n");
261}
262
263
264
265
266
267
268
269
270
271unsigned int stack_trace_save(unsigned long *store, unsigned int size,
272 unsigned int skipnr)
273{
274 struct stack_trace trace = {
275 .entries = store,
276 .max_entries = size,
277 .skip = skipnr + 1,
278 };
279
280 save_stack_trace(&trace);
281 return trace.nr_entries;
282}
283EXPORT_SYMBOL_GPL(stack_trace_save);
284
285
286
287
288
289
290
291
292
293
294unsigned int stack_trace_save_tsk(struct task_struct *task,
295 unsigned long *store, unsigned int size,
296 unsigned int skipnr)
297{
298 struct stack_trace trace = {
299 .entries = store,
300 .max_entries = size,
301 .skip = skipnr + 1,
302 };
303
304 save_stack_trace_tsk(task, &trace);
305 return trace.nr_entries;
306}
307
308
309
310
311
312
313
314
315
316
317unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store,
318 unsigned int size, unsigned int skipnr)
319{
320 struct stack_trace trace = {
321 .entries = store,
322 .max_entries = size,
323 .skip = skipnr,
324 };
325
326 save_stack_trace_regs(regs, &trace);
327 return trace.nr_entries;
328}
329
330#ifdef CONFIG_HAVE_RELIABLE_STACKTRACE
331
332
333
334
335
336
337
338
339
340
341
342
343int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store,
344 unsigned int size)
345{
346 struct stack_trace trace = {
347 .entries = store,
348 .max_entries = size,
349 };
350 int ret = save_stack_trace_tsk_reliable(tsk, &trace);
351
352 return ret ? ret : trace.nr_entries;
353}
354#endif
355
356#ifdef CONFIG_USER_STACKTRACE_SUPPORT
357
358
359
360
361
362
363
364unsigned int stack_trace_save_user(unsigned long *store, unsigned int size)
365{
366 struct stack_trace trace = {
367 .entries = store,
368 .max_entries = size,
369 };
370
371 save_stack_trace_user(&trace);
372 return trace.nr_entries;
373}
374#endif
375
376#endif
377