x86/ioapic: Cleanup the timer_works() irqflags mess
[linux-2.6-microblaze.git] / kernel / stacktrace.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * kernel/stacktrace.c
4  *
5  * Stack trace management functions
6  *
7  *  Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
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  * stack_trace_print - Print the entries in the stack trace
19  * @entries:    Pointer to storage array
20  * @nr_entries: Number of entries in the storage array
21  * @spaces:     Number of leading spaces to print
22  */
23 void stack_trace_print(const 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 }
34 EXPORT_SYMBOL_GPL(stack_trace_print);
35
36 /**
37  * stack_trace_snprint - Print the entries in the stack trace into a buffer
38  * @buf:        Pointer to the print buffer
39  * @size:       Size of the print buffer
40  * @entries:    Pointer to storage array
41  * @nr_entries: Number of entries in the storage array
42  * @spaces:     Number of leading spaces to print
43  *
44  * Return: Number of bytes printed.
45  */
46 int stack_trace_snprint(char *buf, size_t size, const 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 }
70 EXPORT_SYMBOL_GPL(stack_trace_snprint);
71
72 #ifdef CONFIG_ARCH_STACKWALK
73
74 struct stacktrace_cookie {
75         unsigned long   *store;
76         unsigned int    size;
77         unsigned int    skip;
78         unsigned int    len;
79 };
80
81 static bool stack_trace_consume_entry(void *cookie, unsigned long addr)
82 {
83         struct stacktrace_cookie *c = cookie;
84
85         if (c->len >= c->size)
86                 return false;
87
88         if (c->skip > 0) {
89                 c->skip--;
90                 return true;
91         }
92         c->store[c->len++] = addr;
93         return c->len < c->size;
94 }
95
96 static bool stack_trace_consume_entry_nosched(void *cookie, unsigned long addr)
97 {
98         if (in_sched_functions(addr))
99                 return true;
100         return stack_trace_consume_entry(cookie, addr);
101 }
102
103 /**
104  * stack_trace_save - Save a stack trace into a storage array
105  * @store:      Pointer to storage array
106  * @size:       Size of the storage array
107  * @skipnr:     Number of entries to skip at the start of the stack trace
108  *
109  * Return: Number of trace entries stored.
110  */
111 unsigned int stack_trace_save(unsigned long *store, unsigned int size,
112                               unsigned int skipnr)
113 {
114         stack_trace_consume_fn consume_entry = stack_trace_consume_entry;
115         struct stacktrace_cookie c = {
116                 .store  = store,
117                 .size   = size,
118                 .skip   = skipnr + 1,
119         };
120
121         arch_stack_walk(consume_entry, &c, current, NULL);
122         return c.len;
123 }
124 EXPORT_SYMBOL_GPL(stack_trace_save);
125
126 /**
127  * stack_trace_save_tsk - Save a task stack trace into a storage array
128  * @task:       The task to examine
129  * @store:      Pointer to storage array
130  * @size:       Size of the storage array
131  * @skipnr:     Number of entries to skip at the start of the stack trace
132  *
133  * Return: Number of trace entries stored.
134  */
135 unsigned int stack_trace_save_tsk(struct task_struct *tsk, unsigned long *store,
136                                   unsigned int size, unsigned int skipnr)
137 {
138         stack_trace_consume_fn consume_entry = stack_trace_consume_entry_nosched;
139         struct stacktrace_cookie c = {
140                 .store  = store,
141                 .size   = size,
142                 /* skip this function if they are tracing us */
143                 .skip   = skipnr + (current == tsk),
144         };
145
146         if (!try_get_task_stack(tsk))
147                 return 0;
148
149         arch_stack_walk(consume_entry, &c, tsk, NULL);
150         put_task_stack(tsk);
151         return c.len;
152 }
153
154 /**
155  * stack_trace_save_regs - Save a stack trace based on pt_regs into a storage array
156  * @regs:       Pointer to pt_regs to examine
157  * @store:      Pointer to storage array
158  * @size:       Size of the storage array
159  * @skipnr:     Number of entries to skip at the start of the stack trace
160  *
161  * Return: Number of trace entries stored.
162  */
163 unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store,
164                                    unsigned int size, unsigned int skipnr)
165 {
166         stack_trace_consume_fn consume_entry = stack_trace_consume_entry;
167         struct stacktrace_cookie c = {
168                 .store  = store,
169                 .size   = size,
170                 .skip   = skipnr,
171         };
172
173         arch_stack_walk(consume_entry, &c, current, regs);
174         return c.len;
175 }
176
177 #ifdef CONFIG_HAVE_RELIABLE_STACKTRACE
178 /**
179  * stack_trace_save_tsk_reliable - Save task stack with verification
180  * @tsk:        Pointer to the task to examine
181  * @store:      Pointer to storage array
182  * @size:       Size of the storage array
183  *
184  * Return:      An error if it detects any unreliable features of the
185  *              stack. Otherwise it guarantees that the stack trace is
186  *              reliable and returns the number of entries stored.
187  *
188  * If the task is not 'current', the caller *must* ensure the task is inactive.
189  */
190 int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store,
191                                   unsigned int size)
192 {
193         stack_trace_consume_fn consume_entry = stack_trace_consume_entry;
194         struct stacktrace_cookie c = {
195                 .store  = store,
196                 .size   = size,
197         };
198         int ret;
199
200         /*
201          * If the task doesn't have a stack (e.g., a zombie), the stack is
202          * "reliably" empty.
203          */
204         if (!try_get_task_stack(tsk))
205                 return 0;
206
207         ret = arch_stack_walk_reliable(consume_entry, &c, tsk);
208         put_task_stack(tsk);
209         return ret ? ret : c.len;
210 }
211 #endif
212
213 #ifdef CONFIG_USER_STACKTRACE_SUPPORT
214 /**
215  * stack_trace_save_user - Save a user space stack trace into a storage array
216  * @store:      Pointer to storage array
217  * @size:       Size of the storage array
218  *
219  * Return: Number of trace entries stored.
220  */
221 unsigned int stack_trace_save_user(unsigned long *store, unsigned int size)
222 {
223         stack_trace_consume_fn consume_entry = stack_trace_consume_entry;
224         struct stacktrace_cookie c = {
225                 .store  = store,
226                 .size   = size,
227         };
228         mm_segment_t fs;
229
230         /* Trace user stack if not a kernel thread */
231         if (current->flags & PF_KTHREAD)
232                 return 0;
233
234         fs = force_uaccess_begin();
235         arch_stack_walk_user(consume_entry, &c, task_pt_regs(current));
236         force_uaccess_end(fs);
237
238         return c.len;
239 }
240 #endif
241
242 #else /* CONFIG_ARCH_STACKWALK */
243
244 /*
245  * Architectures that do not implement save_stack_trace_*()
246  * get these weak aliases and once-per-bootup warnings
247  * (whenever this facility is utilized - for example by procfs):
248  */
249 __weak void
250 save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
251 {
252         WARN_ONCE(1, KERN_INFO "save_stack_trace_tsk() not implemented yet.\n");
253 }
254
255 __weak void
256 save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace)
257 {
258         WARN_ONCE(1, KERN_INFO "save_stack_trace_regs() not implemented yet.\n");
259 }
260
261 /**
262  * stack_trace_save - Save a stack trace into a storage array
263  * @store:      Pointer to storage array
264  * @size:       Size of the storage array
265  * @skipnr:     Number of entries to skip at the start of the stack trace
266  *
267  * Return: Number of trace entries stored
268  */
269 unsigned int stack_trace_save(unsigned long *store, unsigned int size,
270                               unsigned int skipnr)
271 {
272         struct stack_trace trace = {
273                 .entries        = store,
274                 .max_entries    = size,
275                 .skip           = skipnr + 1,
276         };
277
278         save_stack_trace(&trace);
279         return trace.nr_entries;
280 }
281 EXPORT_SYMBOL_GPL(stack_trace_save);
282
283 /**
284  * stack_trace_save_tsk - Save a task stack trace into a storage array
285  * @task:       The task to examine
286  * @store:      Pointer to storage array
287  * @size:       Size of the storage array
288  * @skipnr:     Number of entries to skip at the start of the stack trace
289  *
290  * Return: Number of trace entries stored
291  */
292 unsigned int stack_trace_save_tsk(struct task_struct *task,
293                                   unsigned long *store, unsigned int size,
294                                   unsigned int skipnr)
295 {
296         struct stack_trace trace = {
297                 .entries        = store,
298                 .max_entries    = size,
299                 /* skip this function if they are tracing us */
300                 .skip   = skipnr + (current == task),
301         };
302
303         save_stack_trace_tsk(task, &trace);
304         return trace.nr_entries;
305 }
306
307 /**
308  * stack_trace_save_regs - Save a stack trace based on pt_regs into a storage array
309  * @regs:       Pointer to pt_regs to examine
310  * @store:      Pointer to storage array
311  * @size:       Size of the storage array
312  * @skipnr:     Number of entries to skip at the start of the stack trace
313  *
314  * Return: Number of trace entries stored
315  */
316 unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store,
317                                    unsigned int size, unsigned int skipnr)
318 {
319         struct stack_trace trace = {
320                 .entries        = store,
321                 .max_entries    = size,
322                 .skip           = skipnr,
323         };
324
325         save_stack_trace_regs(regs, &trace);
326         return trace.nr_entries;
327 }
328
329 #ifdef CONFIG_HAVE_RELIABLE_STACKTRACE
330 /**
331  * stack_trace_save_tsk_reliable - Save task stack with verification
332  * @tsk:        Pointer to the task to examine
333  * @store:      Pointer to storage array
334  * @size:       Size of the storage array
335  *
336  * Return:      An error if it detects any unreliable features of the
337  *              stack. Otherwise it guarantees that the stack trace is
338  *              reliable and returns the number of entries stored.
339  *
340  * If the task is not 'current', the caller *must* ensure the task is inactive.
341  */
342 int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store,
343                                   unsigned int size)
344 {
345         struct stack_trace trace = {
346                 .entries        = store,
347                 .max_entries    = size,
348         };
349         int ret = save_stack_trace_tsk_reliable(tsk, &trace);
350
351         return ret ? ret : trace.nr_entries;
352 }
353 #endif
354
355 #ifdef CONFIG_USER_STACKTRACE_SUPPORT
356 /**
357  * stack_trace_save_user - Save a user space stack trace into a storage array
358  * @store:      Pointer to storage array
359  * @size:       Size of the storage array
360  *
361  * Return: Number of trace entries stored
362  */
363 unsigned int stack_trace_save_user(unsigned long *store, unsigned int size)
364 {
365         struct stack_trace trace = {
366                 .entries        = store,
367                 .max_entries    = size,
368         };
369
370         save_stack_trace_user(&trace);
371         return trace.nr_entries;
372 }
373 #endif /* CONFIG_USER_STACKTRACE_SUPPORT */
374
375 #endif /* !CONFIG_ARCH_STACKWALK */