Loading...
1/*
2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation, version 2.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11 * NON INFRINGEMENT. See the GNU General Public License for
12 * more details.
13 */
14
15#include <linux/sched.h>
16#include <linux/kernel.h>
17#include <linux/kprobes.h>
18#include <linux/module.h>
19#include <linux/pfn.h>
20#include <linux/kallsyms.h>
21#include <linux/stacktrace.h>
22#include <linux/uaccess.h>
23#include <linux/mmzone.h>
24#include <linux/dcache.h>
25#include <linux/fs.h>
26#include <asm/backtrace.h>
27#include <asm/page.h>
28#include <asm/ucontext.h>
29#include <asm/switch_to.h>
30#include <asm/sigframe.h>
31#include <asm/stack.h>
32#include <arch/abi.h>
33#include <arch/interrupts.h>
34
35#define KBT_ONGOING 0 /* Backtrace still ongoing */
36#define KBT_DONE 1 /* Backtrace cleanly completed */
37#define KBT_RUNNING 2 /* Can't run backtrace on a running task */
38#define KBT_LOOP 3 /* Backtrace entered a loop */
39
40/* Is address on the specified kernel stack? */
41static int in_kernel_stack(struct KBacktraceIterator *kbt, unsigned long sp)
42{
43 ulong kstack_base = (ulong) kbt->task->stack;
44 if (kstack_base == 0) /* corrupt task pointer; just follow stack... */
45 return sp >= PAGE_OFFSET && sp < (unsigned long)high_memory;
46 return sp >= kstack_base && sp < kstack_base + THREAD_SIZE;
47}
48
49/* Callback for backtracer; basically a glorified memcpy */
50static bool read_memory_func(void *result, unsigned long address,
51 unsigned int size, void *vkbt)
52{
53 int retval;
54 struct KBacktraceIterator *kbt = (struct KBacktraceIterator *)vkbt;
55
56 if (address == 0)
57 return 0;
58 if (__kernel_text_address(address)) {
59 /* OK to read kernel code. */
60 } else if (address >= PAGE_OFFSET) {
61 /* We only tolerate kernel-space reads of this task's stack */
62 if (!in_kernel_stack(kbt, address))
63 return 0;
64 } else if (!kbt->is_current) {
65 return 0; /* can't read from other user address spaces */
66 }
67 pagefault_disable();
68 retval = __copy_from_user_inatomic(result,
69 (void __user __force *)address,
70 size);
71 pagefault_enable();
72 return (retval == 0);
73}
74
75/* Return a pt_regs pointer for a valid fault handler frame */
76static struct pt_regs *valid_fault_handler(struct KBacktraceIterator* kbt)
77{
78 const char *fault = NULL; /* happy compiler */
79 char fault_buf[64];
80 unsigned long sp = kbt->it.sp;
81 struct pt_regs *p;
82
83 if (sp % sizeof(long) != 0)
84 return NULL;
85 if (!in_kernel_stack(kbt, sp))
86 return NULL;
87 if (!in_kernel_stack(kbt, sp + C_ABI_SAVE_AREA_SIZE + PTREGS_SIZE-1))
88 return NULL;
89 p = (struct pt_regs *)(sp + C_ABI_SAVE_AREA_SIZE);
90 if (p->faultnum == INT_SWINT_1 || p->faultnum == INT_SWINT_1_SIGRETURN)
91 fault = "syscall";
92 else {
93 if (kbt->verbose) { /* else we aren't going to use it */
94 snprintf(fault_buf, sizeof(fault_buf),
95 "interrupt %ld", p->faultnum);
96 fault = fault_buf;
97 }
98 }
99 if (EX1_PL(p->ex1) == KERNEL_PL &&
100 __kernel_text_address(p->pc) &&
101 in_kernel_stack(kbt, p->sp) &&
102 p->sp >= sp) {
103 if (kbt->verbose)
104 pr_err(" <%s while in kernel mode>\n", fault);
105 } else if (EX1_PL(p->ex1) == USER_PL &&
106 p->pc < PAGE_OFFSET &&
107 p->sp < PAGE_OFFSET) {
108 if (kbt->verbose)
109 pr_err(" <%s while in user mode>\n", fault);
110 } else if (kbt->verbose) {
111 pr_err(" (odd fault: pc %#lx, sp %#lx, ex1 %#lx?)\n",
112 p->pc, p->sp, p->ex1);
113 p = NULL;
114 }
115 if (!kbt->profile || (INT_MASK(p->faultnum) & QUEUED_INTERRUPTS) == 0)
116 return p;
117 return NULL;
118}
119
120/* Is the pc pointing to a sigreturn trampoline? */
121static int is_sigreturn(unsigned long pc)
122{
123 return (pc == VDSO_BASE);
124}
125
126/* Return a pt_regs pointer for a valid signal handler frame */
127static struct pt_regs *valid_sigframe(struct KBacktraceIterator* kbt,
128 struct rt_sigframe* kframe)
129{
130 BacktraceIterator *b = &kbt->it;
131
132 if (b->pc == VDSO_BASE && b->sp < PAGE_OFFSET &&
133 b->sp % sizeof(long) == 0) {
134 int retval;
135 pagefault_disable();
136 retval = __copy_from_user_inatomic(
137 kframe, (void __user __force *)b->sp,
138 sizeof(*kframe));
139 pagefault_enable();
140 if (retval != 0 ||
141 (unsigned int)(kframe->info.si_signo) >= _NSIG)
142 return NULL;
143 if (kbt->verbose) {
144 pr_err(" <received signal %d>\n",
145 kframe->info.si_signo);
146 }
147 return (struct pt_regs *)&kframe->uc.uc_mcontext;
148 }
149 return NULL;
150}
151
152static int KBacktraceIterator_is_sigreturn(struct KBacktraceIterator *kbt)
153{
154 return is_sigreturn(kbt->it.pc);
155}
156
157static int KBacktraceIterator_restart(struct KBacktraceIterator *kbt)
158{
159 struct pt_regs *p;
160 struct rt_sigframe kframe;
161
162 p = valid_fault_handler(kbt);
163 if (p == NULL)
164 p = valid_sigframe(kbt, &kframe);
165 if (p == NULL)
166 return 0;
167 backtrace_init(&kbt->it, read_memory_func, kbt,
168 p->pc, p->lr, p->sp, p->regs[52]);
169 kbt->new_context = 1;
170 return 1;
171}
172
173/* Find a frame that isn't a sigreturn, if there is one. */
174static int KBacktraceIterator_next_item_inclusive(
175 struct KBacktraceIterator *kbt)
176{
177 for (;;) {
178 do {
179 if (!KBacktraceIterator_is_sigreturn(kbt))
180 return KBT_ONGOING;
181 } while (backtrace_next(&kbt->it));
182
183 if (!KBacktraceIterator_restart(kbt))
184 return KBT_DONE;
185 }
186}
187
188/*
189 * If the current sp is on a page different than what we recorded
190 * as the top-of-kernel-stack last time we context switched, we have
191 * probably blown the stack, and nothing is going to work out well.
192 * If we can at least get out a warning, that may help the debug,
193 * though we probably won't be able to backtrace into the code that
194 * actually did the recursive damage.
195 */
196static void validate_stack(struct pt_regs *regs)
197{
198 int cpu = smp_processor_id();
199 unsigned long ksp0 = get_current_ksp0();
200 unsigned long ksp0_base = ksp0 - THREAD_SIZE;
201 unsigned long sp = stack_pointer;
202
203 if (EX1_PL(regs->ex1) == KERNEL_PL && regs->sp >= ksp0) {
204 pr_err("WARNING: cpu %d: kernel stack page %#lx underrun!\n"
205 " sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
206 cpu, ksp0_base, sp, regs->sp, regs->pc, regs->lr);
207 }
208
209 else if (sp < ksp0_base + sizeof(struct thread_info)) {
210 pr_err("WARNING: cpu %d: kernel stack page %#lx overrun!\n"
211 " sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
212 cpu, ksp0_base, sp, regs->sp, regs->pc, regs->lr);
213 }
214}
215
216void KBacktraceIterator_init(struct KBacktraceIterator *kbt,
217 struct task_struct *t, struct pt_regs *regs)
218{
219 unsigned long pc, lr, sp, r52;
220 int is_current;
221
222 /*
223 * Set up callback information. We grab the kernel stack base
224 * so we will allow reads of that address range.
225 */
226 is_current = (t == NULL || t == current);
227 kbt->is_current = is_current;
228 if (is_current)
229 t = validate_current();
230 kbt->task = t;
231 kbt->verbose = 0; /* override in caller if desired */
232 kbt->profile = 0; /* override in caller if desired */
233 kbt->end = KBT_ONGOING;
234 kbt->new_context = 1;
235 if (is_current)
236 validate_stack(regs);
237
238 if (regs == NULL) {
239 if (is_current || t->state == TASK_RUNNING) {
240 /* Can't do this; we need registers */
241 kbt->end = KBT_RUNNING;
242 return;
243 }
244 pc = get_switch_to_pc();
245 lr = t->thread.pc;
246 sp = t->thread.ksp;
247 r52 = 0;
248 } else {
249 pc = regs->pc;
250 lr = regs->lr;
251 sp = regs->sp;
252 r52 = regs->regs[52];
253 }
254
255 backtrace_init(&kbt->it, read_memory_func, kbt, pc, lr, sp, r52);
256 kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
257}
258EXPORT_SYMBOL(KBacktraceIterator_init);
259
260int KBacktraceIterator_end(struct KBacktraceIterator *kbt)
261{
262 return kbt->end != KBT_ONGOING;
263}
264EXPORT_SYMBOL(KBacktraceIterator_end);
265
266void KBacktraceIterator_next(struct KBacktraceIterator *kbt)
267{
268 unsigned long old_pc = kbt->it.pc, old_sp = kbt->it.sp;
269 kbt->new_context = 0;
270 if (!backtrace_next(&kbt->it) && !KBacktraceIterator_restart(kbt)) {
271 kbt->end = KBT_DONE;
272 return;
273 }
274 kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
275 if (old_pc == kbt->it.pc && old_sp == kbt->it.sp) {
276 /* Trapped in a loop; give up. */
277 kbt->end = KBT_LOOP;
278 }
279}
280EXPORT_SYMBOL(KBacktraceIterator_next);
281
282static void describe_addr(struct KBacktraceIterator *kbt,
283 unsigned long address,
284 int have_mmap_sem, char *buf, size_t bufsize)
285{
286 struct vm_area_struct *vma;
287 size_t namelen, remaining;
288 unsigned long size, offset, adjust;
289 char *p, *modname;
290 const char *name;
291 int rc;
292
293 /*
294 * Look one byte back for every caller frame (i.e. those that
295 * aren't a new context) so we look up symbol data for the
296 * call itself, not the following instruction, which may be on
297 * a different line (or in a different function).
298 */
299 adjust = !kbt->new_context;
300 address -= adjust;
301
302 if (address >= PAGE_OFFSET) {
303 /* Handle kernel symbols. */
304 BUG_ON(bufsize < KSYM_NAME_LEN);
305 name = kallsyms_lookup(address, &size, &offset,
306 &modname, buf);
307 if (name == NULL) {
308 buf[0] = '\0';
309 return;
310 }
311 namelen = strlen(buf);
312 remaining = (bufsize - 1) - namelen;
313 p = buf + namelen;
314 rc = snprintf(p, remaining, "+%#lx/%#lx ",
315 offset + adjust, size);
316 if (modname && rc < remaining)
317 snprintf(p + rc, remaining - rc, "[%s] ", modname);
318 buf[bufsize-1] = '\0';
319 return;
320 }
321
322 /* If we don't have the mmap_sem, we can't show any more info. */
323 buf[0] = '\0';
324 if (!have_mmap_sem)
325 return;
326
327 /* Find vma info. */
328 vma = find_vma(kbt->task->mm, address);
329 if (vma == NULL || address < vma->vm_start) {
330 snprintf(buf, bufsize, "[unmapped address] ");
331 return;
332 }
333
334 if (vma->vm_file) {
335 char *s;
336 p = d_path(&vma->vm_file->f_path, buf, bufsize);
337 if (IS_ERR(p))
338 p = "?";
339 s = strrchr(p, '/');
340 if (s)
341 p = s+1;
342 } else {
343 p = "anon";
344 }
345
346 /* Generate a string description of the vma info. */
347 namelen = strlen(p);
348 remaining = (bufsize - 1) - namelen;
349 memmove(buf, p, namelen);
350 snprintf(buf + namelen, remaining, "[%lx+%lx] ",
351 vma->vm_start, vma->vm_end - vma->vm_start);
352}
353
354/*
355 * This method wraps the backtracer's more generic support.
356 * It is only invoked from the architecture-specific code; show_stack()
357 * and dump_stack() (in entry.S) are architecture-independent entry points.
358 */
359void tile_show_stack(struct KBacktraceIterator *kbt, int headers)
360{
361 int i;
362 int have_mmap_sem = 0;
363
364 if (headers) {
365 /*
366 * Add a blank line since if we are called from panic(),
367 * then bust_spinlocks() spit out a space in front of us
368 * and it will mess up our KERN_ERR.
369 */
370 pr_err("\n");
371 pr_err("Starting stack dump of tid %d, pid %d (%s)"
372 " on cpu %d at cycle %lld\n",
373 kbt->task->pid, kbt->task->tgid, kbt->task->comm,
374 smp_processor_id(), get_cycles());
375 }
376 kbt->verbose = 1;
377 i = 0;
378 for (; !KBacktraceIterator_end(kbt); KBacktraceIterator_next(kbt)) {
379 char namebuf[KSYM_NAME_LEN+100];
380 unsigned long address = kbt->it.pc;
381
382 /* Try to acquire the mmap_sem as we pass into userspace. */
383 if (address < PAGE_OFFSET && !have_mmap_sem && kbt->task->mm)
384 have_mmap_sem =
385 down_read_trylock(&kbt->task->mm->mmap_sem);
386
387 describe_addr(kbt, address, have_mmap_sem,
388 namebuf, sizeof(namebuf));
389
390 pr_err(" frame %d: 0x%lx %s(sp 0x%lx)\n",
391 i++, address, namebuf, (unsigned long)(kbt->it.sp));
392
393 if (i >= 100) {
394 pr_err("Stack dump truncated"
395 " (%d frames)\n", i);
396 break;
397 }
398 }
399 if (kbt->end == KBT_LOOP)
400 pr_err("Stack dump stopped; next frame identical to this one\n");
401 if (headers)
402 pr_err("Stack dump complete\n");
403 if (have_mmap_sem)
404 up_read(&kbt->task->mm->mmap_sem);
405}
406EXPORT_SYMBOL(tile_show_stack);
407
408
409/* This is called from show_regs() and _dump_stack() */
410void dump_stack_regs(struct pt_regs *regs)
411{
412 struct KBacktraceIterator kbt;
413 KBacktraceIterator_init(&kbt, NULL, regs);
414 tile_show_stack(&kbt, 1);
415}
416EXPORT_SYMBOL(dump_stack_regs);
417
418static struct pt_regs *regs_to_pt_regs(struct pt_regs *regs,
419 ulong pc, ulong lr, ulong sp, ulong r52)
420{
421 memset(regs, 0, sizeof(struct pt_regs));
422 regs->pc = pc;
423 regs->lr = lr;
424 regs->sp = sp;
425 regs->regs[52] = r52;
426 return regs;
427}
428
429/* This is called from dump_stack() and just converts to pt_regs */
430void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
431{
432 struct pt_regs regs;
433 dump_stack_regs(regs_to_pt_regs(®s, pc, lr, sp, r52));
434}
435
436/* This is called from KBacktraceIterator_init_current() */
437void _KBacktraceIterator_init_current(struct KBacktraceIterator *kbt, ulong pc,
438 ulong lr, ulong sp, ulong r52)
439{
440 struct pt_regs regs;
441 KBacktraceIterator_init(kbt, NULL,
442 regs_to_pt_regs(®s, pc, lr, sp, r52));
443}
444
445/* This is called only from kernel/sched.c, with esp == NULL */
446void show_stack(struct task_struct *task, unsigned long *esp)
447{
448 struct KBacktraceIterator kbt;
449 if (task == NULL || task == current)
450 KBacktraceIterator_init_current(&kbt);
451 else
452 KBacktraceIterator_init(&kbt, task, NULL);
453 tile_show_stack(&kbt, 0);
454}
455
456#ifdef CONFIG_STACKTRACE
457
458/* Support generic Linux stack API too */
459
460void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace)
461{
462 struct KBacktraceIterator kbt;
463 int skip = trace->skip;
464 int i = 0;
465
466 if (task == NULL || task == current)
467 KBacktraceIterator_init_current(&kbt);
468 else
469 KBacktraceIterator_init(&kbt, task, NULL);
470 for (; !KBacktraceIterator_end(&kbt); KBacktraceIterator_next(&kbt)) {
471 if (skip) {
472 --skip;
473 continue;
474 }
475 if (i >= trace->max_entries || kbt.it.pc < PAGE_OFFSET)
476 break;
477 trace->entries[i++] = kbt.it.pc;
478 }
479 trace->nr_entries = i;
480}
481EXPORT_SYMBOL(save_stack_trace_tsk);
482
483void save_stack_trace(struct stack_trace *trace)
484{
485 save_stack_trace_tsk(NULL, trace);
486}
487
488#endif
489
490/* In entry.S */
491EXPORT_SYMBOL(KBacktraceIterator_init_current);
1/*
2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation, version 2.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11 * NON INFRINGEMENT. See the GNU General Public License for
12 * more details.
13 */
14
15#include <linux/sched.h>
16#include <linux/kernel.h>
17#include <linux/kprobes.h>
18#include <linux/module.h>
19#include <linux/pfn.h>
20#include <linux/kallsyms.h>
21#include <linux/stacktrace.h>
22#include <linux/uaccess.h>
23#include <linux/mmzone.h>
24#include <linux/dcache.h>
25#include <linux/fs.h>
26#include <linux/string.h>
27#include <asm/backtrace.h>
28#include <asm/page.h>
29#include <asm/ucontext.h>
30#include <asm/switch_to.h>
31#include <asm/sigframe.h>
32#include <asm/stack.h>
33#include <asm/vdso.h>
34#include <arch/abi.h>
35#include <arch/interrupts.h>
36
37#define KBT_ONGOING 0 /* Backtrace still ongoing */
38#define KBT_DONE 1 /* Backtrace cleanly completed */
39#define KBT_RUNNING 2 /* Can't run backtrace on a running task */
40#define KBT_LOOP 3 /* Backtrace entered a loop */
41
42/* Is address on the specified kernel stack? */
43static int in_kernel_stack(struct KBacktraceIterator *kbt, unsigned long sp)
44{
45 ulong kstack_base = (ulong) kbt->task->stack;
46 if (kstack_base == 0) /* corrupt task pointer; just follow stack... */
47 return sp >= PAGE_OFFSET && sp < (unsigned long)high_memory;
48 return sp >= kstack_base && sp < kstack_base + THREAD_SIZE;
49}
50
51/* Callback for backtracer; basically a glorified memcpy */
52static bool read_memory_func(void *result, unsigned long address,
53 unsigned int size, void *vkbt)
54{
55 int retval;
56 struct KBacktraceIterator *kbt = (struct KBacktraceIterator *)vkbt;
57
58 if (address == 0)
59 return 0;
60 if (__kernel_text_address(address)) {
61 /* OK to read kernel code. */
62 } else if (address >= PAGE_OFFSET) {
63 /* We only tolerate kernel-space reads of this task's stack */
64 if (!in_kernel_stack(kbt, address))
65 return 0;
66 } else if (!kbt->is_current) {
67 return 0; /* can't read from other user address spaces */
68 }
69 pagefault_disable();
70 retval = __copy_from_user_inatomic(result,
71 (void __user __force *)address,
72 size);
73 pagefault_enable();
74 return (retval == 0);
75}
76
77/* Return a pt_regs pointer for a valid fault handler frame */
78static struct pt_regs *valid_fault_handler(struct KBacktraceIterator* kbt)
79{
80 const char *fault = NULL; /* happy compiler */
81 char fault_buf[64];
82 unsigned long sp = kbt->it.sp;
83 struct pt_regs *p;
84
85 if (sp % sizeof(long) != 0)
86 return NULL;
87 if (!in_kernel_stack(kbt, sp))
88 return NULL;
89 if (!in_kernel_stack(kbt, sp + C_ABI_SAVE_AREA_SIZE + PTREGS_SIZE-1))
90 return NULL;
91 p = (struct pt_regs *)(sp + C_ABI_SAVE_AREA_SIZE);
92 if (p->faultnum == INT_SWINT_1 || p->faultnum == INT_SWINT_1_SIGRETURN)
93 fault = "syscall";
94 else {
95 if (kbt->verbose) { /* else we aren't going to use it */
96 snprintf(fault_buf, sizeof(fault_buf),
97 "interrupt %ld", p->faultnum);
98 fault = fault_buf;
99 }
100 }
101 if (EX1_PL(p->ex1) == KERNEL_PL &&
102 __kernel_text_address(p->pc) &&
103 in_kernel_stack(kbt, p->sp) &&
104 p->sp >= sp) {
105 if (kbt->verbose)
106 pr_err(" <%s while in kernel mode>\n", fault);
107 } else if (user_mode(p) &&
108 p->sp < PAGE_OFFSET && p->sp != 0) {
109 if (kbt->verbose)
110 pr_err(" <%s while in user mode>\n", fault);
111 } else if (kbt->verbose) {
112 pr_err(" (odd fault: pc %#lx, sp %#lx, ex1 %#lx?)\n",
113 p->pc, p->sp, p->ex1);
114 p = NULL;
115 }
116 if (!kbt->profile || ((1ULL << p->faultnum) & QUEUED_INTERRUPTS) == 0)
117 return p;
118 return NULL;
119}
120
121/* Is the pc pointing to a sigreturn trampoline? */
122static int is_sigreturn(unsigned long pc)
123{
124 return current->mm && (pc == VDSO_SYM(&__vdso_rt_sigreturn));
125}
126
127/* Return a pt_regs pointer for a valid signal handler frame */
128static struct pt_regs *valid_sigframe(struct KBacktraceIterator* kbt,
129 struct rt_sigframe* kframe)
130{
131 BacktraceIterator *b = &kbt->it;
132
133 if (is_sigreturn(b->pc) && b->sp < PAGE_OFFSET &&
134 b->sp % sizeof(long) == 0) {
135 int retval;
136 pagefault_disable();
137 retval = __copy_from_user_inatomic(
138 kframe, (void __user __force *)b->sp,
139 sizeof(*kframe));
140 pagefault_enable();
141 if (retval != 0 ||
142 (unsigned int)(kframe->info.si_signo) >= _NSIG)
143 return NULL;
144 if (kbt->verbose) {
145 pr_err(" <received signal %d>\n",
146 kframe->info.si_signo);
147 }
148 return (struct pt_regs *)&kframe->uc.uc_mcontext;
149 }
150 return NULL;
151}
152
153static int KBacktraceIterator_is_sigreturn(struct KBacktraceIterator *kbt)
154{
155 return is_sigreturn(kbt->it.pc);
156}
157
158static int KBacktraceIterator_restart(struct KBacktraceIterator *kbt)
159{
160 struct pt_regs *p;
161 struct rt_sigframe kframe;
162
163 p = valid_fault_handler(kbt);
164 if (p == NULL)
165 p = valid_sigframe(kbt, &kframe);
166 if (p == NULL)
167 return 0;
168 backtrace_init(&kbt->it, read_memory_func, kbt,
169 p->pc, p->lr, p->sp, p->regs[52]);
170 kbt->new_context = 1;
171 return 1;
172}
173
174/* Find a frame that isn't a sigreturn, if there is one. */
175static int KBacktraceIterator_next_item_inclusive(
176 struct KBacktraceIterator *kbt)
177{
178 for (;;) {
179 do {
180 if (!KBacktraceIterator_is_sigreturn(kbt))
181 return KBT_ONGOING;
182 } while (backtrace_next(&kbt->it));
183
184 if (!KBacktraceIterator_restart(kbt))
185 return KBT_DONE;
186 }
187}
188
189/*
190 * If the current sp is on a page different than what we recorded
191 * as the top-of-kernel-stack last time we context switched, we have
192 * probably blown the stack, and nothing is going to work out well.
193 * If we can at least get out a warning, that may help the debug,
194 * though we probably won't be able to backtrace into the code that
195 * actually did the recursive damage.
196 */
197static void validate_stack(struct pt_regs *regs)
198{
199 int cpu = raw_smp_processor_id();
200 unsigned long ksp0 = get_current_ksp0();
201 unsigned long ksp0_base = ksp0 & -THREAD_SIZE;
202 unsigned long sp = stack_pointer;
203
204 if (EX1_PL(regs->ex1) == KERNEL_PL && regs->sp >= ksp0) {
205 pr_err("WARNING: cpu %d: kernel stack %#lx..%#lx underrun!\n"
206 " sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
207 cpu, ksp0_base, ksp0, sp, regs->sp, regs->pc, regs->lr);
208 }
209
210 else if (sp < ksp0_base + sizeof(struct thread_info)) {
211 pr_err("WARNING: cpu %d: kernel stack %#lx..%#lx overrun!\n"
212 " sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
213 cpu, ksp0_base, ksp0, sp, regs->sp, regs->pc, regs->lr);
214 }
215}
216
217void KBacktraceIterator_init(struct KBacktraceIterator *kbt,
218 struct task_struct *t, struct pt_regs *regs)
219{
220 unsigned long pc, lr, sp, r52;
221 int is_current;
222
223 /*
224 * Set up callback information. We grab the kernel stack base
225 * so we will allow reads of that address range.
226 */
227 is_current = (t == NULL || t == current);
228 kbt->is_current = is_current;
229 if (is_current)
230 t = validate_current();
231 kbt->task = t;
232 kbt->verbose = 0; /* override in caller if desired */
233 kbt->profile = 0; /* override in caller if desired */
234 kbt->end = KBT_ONGOING;
235 kbt->new_context = 1;
236 if (is_current)
237 validate_stack(regs);
238
239 if (regs == NULL) {
240 if (is_current || t->state == TASK_RUNNING) {
241 /* Can't do this; we need registers */
242 kbt->end = KBT_RUNNING;
243 return;
244 }
245 pc = get_switch_to_pc();
246 lr = t->thread.pc;
247 sp = t->thread.ksp;
248 r52 = 0;
249 } else {
250 pc = regs->pc;
251 lr = regs->lr;
252 sp = regs->sp;
253 r52 = regs->regs[52];
254 }
255
256 backtrace_init(&kbt->it, read_memory_func, kbt, pc, lr, sp, r52);
257 kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
258}
259EXPORT_SYMBOL(KBacktraceIterator_init);
260
261int KBacktraceIterator_end(struct KBacktraceIterator *kbt)
262{
263 return kbt->end != KBT_ONGOING;
264}
265EXPORT_SYMBOL(KBacktraceIterator_end);
266
267void KBacktraceIterator_next(struct KBacktraceIterator *kbt)
268{
269 unsigned long old_pc = kbt->it.pc, old_sp = kbt->it.sp;
270 kbt->new_context = 0;
271 if (!backtrace_next(&kbt->it) && !KBacktraceIterator_restart(kbt)) {
272 kbt->end = KBT_DONE;
273 return;
274 }
275 kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
276 if (old_pc == kbt->it.pc && old_sp == kbt->it.sp) {
277 /* Trapped in a loop; give up. */
278 kbt->end = KBT_LOOP;
279 }
280}
281EXPORT_SYMBOL(KBacktraceIterator_next);
282
283static void describe_addr(struct KBacktraceIterator *kbt,
284 unsigned long address,
285 int have_mmap_sem, char *buf, size_t bufsize)
286{
287 struct vm_area_struct *vma;
288 size_t namelen, remaining;
289 unsigned long size, offset, adjust;
290 char *p, *modname;
291 const char *name;
292 int rc;
293
294 /*
295 * Look one byte back for every caller frame (i.e. those that
296 * aren't a new context) so we look up symbol data for the
297 * call itself, not the following instruction, which may be on
298 * a different line (or in a different function).
299 */
300 adjust = !kbt->new_context;
301 address -= adjust;
302
303 if (address >= PAGE_OFFSET) {
304 /* Handle kernel symbols. */
305 BUG_ON(bufsize < KSYM_NAME_LEN);
306 name = kallsyms_lookup(address, &size, &offset,
307 &modname, buf);
308 if (name == NULL) {
309 buf[0] = '\0';
310 return;
311 }
312 namelen = strlen(buf);
313 remaining = (bufsize - 1) - namelen;
314 p = buf + namelen;
315 rc = snprintf(p, remaining, "+%#lx/%#lx ",
316 offset + adjust, size);
317 if (modname && rc < remaining)
318 snprintf(p + rc, remaining - rc, "[%s] ", modname);
319 buf[bufsize-1] = '\0';
320 return;
321 }
322
323 /* If we don't have the mmap_sem, we can't show any more info. */
324 buf[0] = '\0';
325 if (!have_mmap_sem)
326 return;
327
328 /* Find vma info. */
329 vma = find_vma(kbt->task->mm, address);
330 if (vma == NULL || address < vma->vm_start) {
331 snprintf(buf, bufsize, "[unmapped address] ");
332 return;
333 }
334
335 if (vma->vm_file) {
336 p = d_path(&vma->vm_file->f_path, buf, bufsize);
337 if (IS_ERR(p))
338 p = "?";
339 name = kbasename(p);
340 } else {
341 name = "anon";
342 }
343
344 /* Generate a string description of the vma info. */
345 namelen = strlen(name);
346 remaining = (bufsize - 1) - namelen;
347 memmove(buf, name, namelen);
348 snprintf(buf + namelen, remaining, "[%lx+%lx] ",
349 vma->vm_start, vma->vm_end - vma->vm_start);
350}
351
352/*
353 * Avoid possible crash recursion during backtrace. If it happens, it
354 * makes it easy to lose the actual root cause of the failure, so we
355 * put a simple guard on all the backtrace loops.
356 */
357static bool start_backtrace(void)
358{
359 if (current->thread.in_backtrace) {
360 pr_err("Backtrace requested while in backtrace!\n");
361 return false;
362 }
363 current->thread.in_backtrace = true;
364 return true;
365}
366
367static void end_backtrace(void)
368{
369 current->thread.in_backtrace = false;
370}
371
372/*
373 * This method wraps the backtracer's more generic support.
374 * It is only invoked from the architecture-specific code; show_stack()
375 * and dump_stack() (in entry.S) are architecture-independent entry points.
376 */
377void tile_show_stack(struct KBacktraceIterator *kbt, int headers)
378{
379 int i;
380 int have_mmap_sem = 0;
381
382 if (!start_backtrace())
383 return;
384 if (headers) {
385 /*
386 * Add a blank line since if we are called from panic(),
387 * then bust_spinlocks() spit out a space in front of us
388 * and it will mess up our KERN_ERR.
389 */
390 pr_err("\n");
391 pr_err("Starting stack dump of tid %d, pid %d (%s)"
392 " on cpu %d at cycle %lld\n",
393 kbt->task->pid, kbt->task->tgid, kbt->task->comm,
394 raw_smp_processor_id(), get_cycles());
395 }
396 kbt->verbose = 1;
397 i = 0;
398 for (; !KBacktraceIterator_end(kbt); KBacktraceIterator_next(kbt)) {
399 char namebuf[KSYM_NAME_LEN+100];
400 unsigned long address = kbt->it.pc;
401
402 /* Try to acquire the mmap_sem as we pass into userspace. */
403 if (address < PAGE_OFFSET && !have_mmap_sem && kbt->task->mm)
404 have_mmap_sem =
405 down_read_trylock(&kbt->task->mm->mmap_sem);
406
407 describe_addr(kbt, address, have_mmap_sem,
408 namebuf, sizeof(namebuf));
409
410 pr_err(" frame %d: 0x%lx %s(sp 0x%lx)\n",
411 i++, address, namebuf, (unsigned long)(kbt->it.sp));
412
413 if (i >= 100) {
414 pr_err("Stack dump truncated"
415 " (%d frames)\n", i);
416 break;
417 }
418 }
419 if (kbt->end == KBT_LOOP)
420 pr_err("Stack dump stopped; next frame identical to this one\n");
421 if (headers)
422 pr_err("Stack dump complete\n");
423 if (have_mmap_sem)
424 up_read(&kbt->task->mm->mmap_sem);
425 end_backtrace();
426}
427EXPORT_SYMBOL(tile_show_stack);
428
429
430/* This is called from show_regs() and _dump_stack() */
431void dump_stack_regs(struct pt_regs *regs)
432{
433 struct KBacktraceIterator kbt;
434 KBacktraceIterator_init(&kbt, NULL, regs);
435 tile_show_stack(&kbt, 1);
436}
437EXPORT_SYMBOL(dump_stack_regs);
438
439static struct pt_regs *regs_to_pt_regs(struct pt_regs *regs,
440 ulong pc, ulong lr, ulong sp, ulong r52)
441{
442 memset(regs, 0, sizeof(struct pt_regs));
443 regs->pc = pc;
444 regs->lr = lr;
445 regs->sp = sp;
446 regs->regs[52] = r52;
447 return regs;
448}
449
450/* This is called from dump_stack() and just converts to pt_regs */
451void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
452{
453 struct pt_regs regs;
454 dump_stack_regs(regs_to_pt_regs(®s, pc, lr, sp, r52));
455}
456
457/* This is called from KBacktraceIterator_init_current() */
458void _KBacktraceIterator_init_current(struct KBacktraceIterator *kbt, ulong pc,
459 ulong lr, ulong sp, ulong r52)
460{
461 struct pt_regs regs;
462 KBacktraceIterator_init(kbt, NULL,
463 regs_to_pt_regs(®s, pc, lr, sp, r52));
464}
465
466/* This is called only from kernel/sched/core.c, with esp == NULL */
467void show_stack(struct task_struct *task, unsigned long *esp)
468{
469 struct KBacktraceIterator kbt;
470 if (task == NULL || task == current)
471 KBacktraceIterator_init_current(&kbt);
472 else
473 KBacktraceIterator_init(&kbt, task, NULL);
474 tile_show_stack(&kbt, 0);
475}
476
477#ifdef CONFIG_STACKTRACE
478
479/* Support generic Linux stack API too */
480
481void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace)
482{
483 struct KBacktraceIterator kbt;
484 int skip = trace->skip;
485 int i = 0;
486
487 if (!start_backtrace())
488 goto done;
489 if (task == NULL || task == current)
490 KBacktraceIterator_init_current(&kbt);
491 else
492 KBacktraceIterator_init(&kbt, task, NULL);
493 for (; !KBacktraceIterator_end(&kbt); KBacktraceIterator_next(&kbt)) {
494 if (skip) {
495 --skip;
496 continue;
497 }
498 if (i >= trace->max_entries || kbt.it.pc < PAGE_OFFSET)
499 break;
500 trace->entries[i++] = kbt.it.pc;
501 }
502 end_backtrace();
503done:
504 trace->nr_entries = i;
505}
506EXPORT_SYMBOL(save_stack_trace_tsk);
507
508void save_stack_trace(struct stack_trace *trace)
509{
510 save_stack_trace_tsk(NULL, trace);
511}
512EXPORT_SYMBOL_GPL(save_stack_trace);
513
514#endif
515
516/* In entry.S */
517EXPORT_SYMBOL(KBacktraceIterator_init_current);