2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
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.
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
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>
26 #include <asm/backtrace.h>
28 #include <asm/ucontext.h>
29 #include <asm/switch_to.h>
30 #include <asm/sigframe.h>
31 #include <asm/stack.h>
34 #include <arch/interrupts.h>
36 #define KBT_ONGOING 0 /* Backtrace still ongoing */
37 #define KBT_DONE 1 /* Backtrace cleanly completed */
38 #define KBT_RUNNING 2 /* Can't run backtrace on a running task */
39 #define KBT_LOOP 3 /* Backtrace entered a loop */
41 /* Is address on the specified kernel stack? */
42 static int in_kernel_stack(struct KBacktraceIterator *kbt, unsigned long sp)
44 ulong kstack_base = (ulong) kbt->task->stack;
45 if (kstack_base == 0) /* corrupt task pointer; just follow stack... */
46 return sp >= PAGE_OFFSET && sp < (unsigned long)high_memory;
47 return sp >= kstack_base && sp < kstack_base + THREAD_SIZE;
50 /* Callback for backtracer; basically a glorified memcpy */
51 static bool read_memory_func(void *result, unsigned long address,
52 unsigned int size, void *vkbt)
55 struct KBacktraceIterator *kbt = (struct KBacktraceIterator *)vkbt;
59 if (__kernel_text_address(address)) {
60 /* OK to read kernel code. */
61 } else if (address >= PAGE_OFFSET) {
62 /* We only tolerate kernel-space reads of this task's stack */
63 if (!in_kernel_stack(kbt, address))
65 } else if (!kbt->is_current) {
66 return 0; /* can't read from other user address spaces */
69 retval = __copy_from_user_inatomic(result,
70 (void __user __force *)address,
76 /* Return a pt_regs pointer for a valid fault handler frame */
77 static struct pt_regs *valid_fault_handler(struct KBacktraceIterator* kbt)
79 const char *fault = NULL; /* happy compiler */
81 unsigned long sp = kbt->it.sp;
84 if (sp % sizeof(long) != 0)
86 if (!in_kernel_stack(kbt, sp))
88 if (!in_kernel_stack(kbt, sp + C_ABI_SAVE_AREA_SIZE + PTREGS_SIZE-1))
90 p = (struct pt_regs *)(sp + C_ABI_SAVE_AREA_SIZE);
91 if (p->faultnum == INT_SWINT_1 || p->faultnum == INT_SWINT_1_SIGRETURN)
94 if (kbt->verbose) { /* else we aren't going to use it */
95 snprintf(fault_buf, sizeof(fault_buf),
96 "interrupt %ld", p->faultnum);
100 if (EX1_PL(p->ex1) == KERNEL_PL &&
101 __kernel_text_address(p->pc) &&
102 in_kernel_stack(kbt, p->sp) &&
105 pr_err(" <%s while in kernel mode>\n", fault);
106 } else if (user_mode(p) &&
107 p->sp < PAGE_OFFSET && p->sp != 0) {
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);
115 if (!kbt->profile || ((1ULL << p->faultnum) & QUEUED_INTERRUPTS) == 0)
120 /* Is the pc pointing to a sigreturn trampoline? */
121 static int is_sigreturn(unsigned long pc)
123 return current->mm && (pc == VDSO_SYM(&__vdso_rt_sigreturn));
126 /* Return a pt_regs pointer for a valid signal handler frame */
127 static struct pt_regs *valid_sigframe(struct KBacktraceIterator* kbt,
128 struct rt_sigframe* kframe)
130 BacktraceIterator *b = &kbt->it;
132 if (is_sigreturn(b->pc) && b->sp < PAGE_OFFSET &&
133 b->sp % sizeof(long) == 0) {
136 retval = __copy_from_user_inatomic(
137 kframe, (void __user __force *)b->sp,
141 (unsigned int)(kframe->info.si_signo) >= _NSIG)
144 pr_err(" <received signal %d>\n",
145 kframe->info.si_signo);
147 return (struct pt_regs *)&kframe->uc.uc_mcontext;
152 static int KBacktraceIterator_is_sigreturn(struct KBacktraceIterator *kbt)
154 return is_sigreturn(kbt->it.pc);
157 static int KBacktraceIterator_restart(struct KBacktraceIterator *kbt)
160 struct rt_sigframe kframe;
162 p = valid_fault_handler(kbt);
164 p = valid_sigframe(kbt, &kframe);
167 backtrace_init(&kbt->it, read_memory_func, kbt,
168 p->pc, p->lr, p->sp, p->regs[52]);
169 kbt->new_context = 1;
173 /* Find a frame that isn't a sigreturn, if there is one. */
174 static int KBacktraceIterator_next_item_inclusive(
175 struct KBacktraceIterator *kbt)
179 if (!KBacktraceIterator_is_sigreturn(kbt))
181 } while (backtrace_next(&kbt->it));
183 if (!KBacktraceIterator_restart(kbt))
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.
196 static void validate_stack(struct pt_regs *regs)
198 int cpu = raw_smp_processor_id();
199 unsigned long ksp0 = get_current_ksp0();
200 unsigned long ksp0_base = ksp0 & -THREAD_SIZE;
201 unsigned long sp = stack_pointer;
203 if (EX1_PL(regs->ex1) == KERNEL_PL && regs->sp >= ksp0) {
204 pr_err("WARNING: cpu %d: kernel stack %#lx..%#lx underrun!\n"
205 " sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
206 cpu, ksp0_base, ksp0, sp, regs->sp, regs->pc, regs->lr);
209 else if (sp < ksp0_base + sizeof(struct thread_info)) {
210 pr_err("WARNING: cpu %d: kernel stack %#lx..%#lx overrun!\n"
211 " sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
212 cpu, ksp0_base, ksp0, sp, regs->sp, regs->pc, regs->lr);
216 void KBacktraceIterator_init(struct KBacktraceIterator *kbt,
217 struct task_struct *t, struct pt_regs *regs)
219 unsigned long pc, lr, sp, r52;
223 * Set up callback information. We grab the kernel stack base
224 * so we will allow reads of that address range.
226 is_current = (t == NULL || t == current);
227 kbt->is_current = is_current;
229 t = validate_current();
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;
236 validate_stack(regs);
239 if (is_current || t->state == TASK_RUNNING) {
240 /* Can't do this; we need registers */
241 kbt->end = KBT_RUNNING;
244 pc = get_switch_to_pc();
252 r52 = regs->regs[52];
255 backtrace_init(&kbt->it, read_memory_func, kbt, pc, lr, sp, r52);
256 kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
258 EXPORT_SYMBOL(KBacktraceIterator_init);
260 int KBacktraceIterator_end(struct KBacktraceIterator *kbt)
262 return kbt->end != KBT_ONGOING;
264 EXPORT_SYMBOL(KBacktraceIterator_end);
266 void KBacktraceIterator_next(struct KBacktraceIterator *kbt)
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)) {
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. */
280 EXPORT_SYMBOL(KBacktraceIterator_next);
282 static void describe_addr(struct KBacktraceIterator *kbt,
283 unsigned long address,
284 int have_mmap_sem, char *buf, size_t bufsize)
286 struct vm_area_struct *vma;
287 size_t namelen, remaining;
288 unsigned long size, offset, adjust;
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).
299 adjust = !kbt->new_context;
302 if (address >= PAGE_OFFSET) {
303 /* Handle kernel symbols. */
304 BUG_ON(bufsize < KSYM_NAME_LEN);
305 name = kallsyms_lookup(address, &size, &offset,
311 namelen = strlen(buf);
312 remaining = (bufsize - 1) - 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';
322 /* If we don't have the mmap_sem, we can't show any more info. */
328 vma = find_vma(kbt->task->mm, address);
329 if (vma == NULL || address < vma->vm_start) {
330 snprintf(buf, bufsize, "[unmapped address] ");
336 p = d_path(&vma->vm_file->f_path, buf, bufsize);
346 /* Generate a string description of the vma info. */
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);
355 * Avoid possible crash recursion during backtrace. If it happens, it
356 * makes it easy to lose the actual root cause of the failure, so we
357 * put a simple guard on all the backtrace loops.
359 static bool start_backtrace(void)
361 if (current->thread.in_backtrace) {
362 pr_err("Backtrace requested while in backtrace!\n");
365 current->thread.in_backtrace = true;
369 static void end_backtrace(void)
371 current->thread.in_backtrace = false;
375 * This method wraps the backtracer's more generic support.
376 * It is only invoked from the architecture-specific code; show_stack()
377 * and dump_stack() (in entry.S) are architecture-independent entry points.
379 void tile_show_stack(struct KBacktraceIterator *kbt, int headers)
382 int have_mmap_sem = 0;
384 if (!start_backtrace())
388 * Add a blank line since if we are called from panic(),
389 * then bust_spinlocks() spit out a space in front of us
390 * and it will mess up our KERN_ERR.
393 pr_err("Starting stack dump of tid %d, pid %d (%s)"
394 " on cpu %d at cycle %lld\n",
395 kbt->task->pid, kbt->task->tgid, kbt->task->comm,
396 raw_smp_processor_id(), get_cycles());
400 for (; !KBacktraceIterator_end(kbt); KBacktraceIterator_next(kbt)) {
401 char namebuf[KSYM_NAME_LEN+100];
402 unsigned long address = kbt->it.pc;
404 /* Try to acquire the mmap_sem as we pass into userspace. */
405 if (address < PAGE_OFFSET && !have_mmap_sem && kbt->task->mm)
407 down_read_trylock(&kbt->task->mm->mmap_sem);
409 describe_addr(kbt, address, have_mmap_sem,
410 namebuf, sizeof(namebuf));
412 pr_err(" frame %d: 0x%lx %s(sp 0x%lx)\n",
413 i++, address, namebuf, (unsigned long)(kbt->it.sp));
416 pr_err("Stack dump truncated"
417 " (%d frames)\n", i);
421 if (kbt->end == KBT_LOOP)
422 pr_err("Stack dump stopped; next frame identical to this one\n");
424 pr_err("Stack dump complete\n");
426 up_read(&kbt->task->mm->mmap_sem);
429 EXPORT_SYMBOL(tile_show_stack);
432 /* This is called from show_regs() and _dump_stack() */
433 void dump_stack_regs(struct pt_regs *regs)
435 struct KBacktraceIterator kbt;
436 KBacktraceIterator_init(&kbt, NULL, regs);
437 tile_show_stack(&kbt, 1);
439 EXPORT_SYMBOL(dump_stack_regs);
441 static struct pt_regs *regs_to_pt_regs(struct pt_regs *regs,
442 ulong pc, ulong lr, ulong sp, ulong r52)
444 memset(regs, 0, sizeof(struct pt_regs));
448 regs->regs[52] = r52;
452 /* This is called from dump_stack() and just converts to pt_regs */
453 void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
456 dump_stack_regs(regs_to_pt_regs(®s, pc, lr, sp, r52));
459 /* This is called from KBacktraceIterator_init_current() */
460 void _KBacktraceIterator_init_current(struct KBacktraceIterator *kbt, ulong pc,
461 ulong lr, ulong sp, ulong r52)
464 KBacktraceIterator_init(kbt, NULL,
465 regs_to_pt_regs(®s, pc, lr, sp, r52));
468 /* This is called only from kernel/sched/core.c, with esp == NULL */
469 void show_stack(struct task_struct *task, unsigned long *esp)
471 struct KBacktraceIterator kbt;
472 if (task == NULL || task == current)
473 KBacktraceIterator_init_current(&kbt);
475 KBacktraceIterator_init(&kbt, task, NULL);
476 tile_show_stack(&kbt, 0);
479 #ifdef CONFIG_STACKTRACE
481 /* Support generic Linux stack API too */
483 void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace)
485 struct KBacktraceIterator kbt;
486 int skip = trace->skip;
489 if (!start_backtrace())
491 if (task == NULL || task == current)
492 KBacktraceIterator_init_current(&kbt);
494 KBacktraceIterator_init(&kbt, task, NULL);
495 for (; !KBacktraceIterator_end(&kbt); KBacktraceIterator_next(&kbt)) {
500 if (i >= trace->max_entries || kbt.it.pc < PAGE_OFFSET)
502 trace->entries[i++] = kbt.it.pc;
506 trace->nr_entries = i;
508 EXPORT_SYMBOL(save_stack_trace_tsk);
510 void save_stack_trace(struct stack_trace *trace)
512 save_stack_trace_tsk(NULL, trace);
514 EXPORT_SYMBOL_GPL(save_stack_trace);
519 EXPORT_SYMBOL(KBacktraceIterator_init_current);