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 <asm/backtrace.h>
26 #include <asm/tlbflush.h>
27 #include <asm/ucontext.h>
28 #include <asm/sigframe.h>
29 #include <asm/stack.h>
31 #include <arch/interrupts.h>
34 /* Is address on the specified kernel stack? */
35 static int in_kernel_stack(struct KBacktraceIterator
*kbt
, VirtualAddress sp
)
37 ulong kstack_base
= (ulong
) kbt
->task
->stack
;
38 if (kstack_base
== 0) /* corrupt task pointer; just follow stack... */
39 return sp
>= PAGE_OFFSET
&& sp
< (unsigned long)high_memory
;
40 return sp
>= kstack_base
&& sp
< kstack_base
+ THREAD_SIZE
;
43 /* Is address in the specified kernel code? */
44 static int in_kernel_text(VirtualAddress address
)
46 return (address
>= MEM_SV_INTRPT
&&
47 address
< MEM_SV_INTRPT
+ HPAGE_SIZE
);
50 /* Is address valid for reading? */
51 static int valid_address(struct KBacktraceIterator
*kbt
, VirtualAddress address
)
53 HV_PTE
*l1_pgtable
= kbt
->pgtable
;
59 pte
= l1_pgtable
[HV_L1_INDEX(address
)];
60 if (!hv_pte_get_present(pte
))
62 pfn
= hv_pte_get_pfn(pte
);
64 if (!pfn_valid(pfn
)) {
65 printk(KERN_ERR
"huge page has bad pfn %#lx\n", pfn
);
68 return hv_pte_get_present(pte
) && hv_pte_get_readable(pte
);
71 page
= pfn_to_page(pfn
);
72 if (PageHighMem(page
)) {
73 printk(KERN_ERR
"L2 page table not in LOWMEM (%#llx)\n",
77 l2_pgtable
= (HV_PTE
*)pfn_to_kaddr(pfn
);
78 pte
= l2_pgtable
[HV_L2_INDEX(address
)];
79 return hv_pte_get_present(pte
) && hv_pte_get_readable(pte
);
82 /* Callback for backtracer; basically a glorified memcpy */
83 static bool read_memory_func(void *result
, VirtualAddress address
,
84 unsigned int size
, void *vkbt
)
87 struct KBacktraceIterator
*kbt
= (struct KBacktraceIterator
*)vkbt
;
88 if (in_kernel_text(address
)) {
89 /* OK to read kernel code. */
90 } else if (address
>= PAGE_OFFSET
) {
91 /* We only tolerate kernel-space reads of this task's stack */
92 if (!in_kernel_stack(kbt
, address
))
94 } else if (kbt
->pgtable
== NULL
) {
95 return 0; /* can't read user space in other tasks */
96 } else if (!valid_address(kbt
, address
)) {
97 return 0; /* invalid user-space address */
100 retval
= __copy_from_user_inatomic(result
, (const void *)address
,
103 return (retval
== 0);
106 /* Return a pt_regs pointer for a valid fault handler frame */
107 static struct pt_regs
*valid_fault_handler(struct KBacktraceIterator
* kbt
)
110 const char *fault
= NULL
; /* happy compiler */
112 VirtualAddress sp
= kbt
->it
.sp
;
115 if (!in_kernel_stack(kbt
, sp
))
117 if (!in_kernel_stack(kbt
, sp
+ C_ABI_SAVE_AREA_SIZE
+ PTREGS_SIZE
-1))
119 p
= (struct pt_regs
*)(sp
+ C_ABI_SAVE_AREA_SIZE
);
120 if (p
->faultnum
== INT_SWINT_1
|| p
->faultnum
== INT_SWINT_1_SIGRETURN
)
123 if (kbt
->verbose
) { /* else we aren't going to use it */
124 snprintf(fault_buf
, sizeof(fault_buf
),
125 "interrupt %ld", p
->faultnum
);
129 if (EX1_PL(p
->ex1
) == KERNEL_PL
&&
130 in_kernel_text(p
->pc
) &&
131 in_kernel_stack(kbt
, p
->sp
) &&
134 printk(KERN_ERR
" <%s while in kernel mode>\n", fault
);
135 } else if (EX1_PL(p
->ex1
) == USER_PL
&&
136 p
->pc
< PAGE_OFFSET
&&
137 p
->sp
< PAGE_OFFSET
) {
139 printk(KERN_ERR
" <%s while in user mode>\n", fault
);
140 } else if (kbt
->verbose
) {
141 printk(KERN_ERR
" (odd fault: pc %#lx, sp %#lx, ex1 %#lx?)\n",
142 p
->pc
, p
->sp
, p
->ex1
);
145 if (!kbt
->profile
|| (INT_MASK(p
->faultnum
) & QUEUED_INTERRUPTS
) == 0)
151 /* Is the pc pointing to a sigreturn trampoline? */
152 static int is_sigreturn(VirtualAddress pc
)
154 return (pc
== VDSO_BASE
);
157 /* Return a pt_regs pointer for a valid signal handler frame */
158 static struct pt_regs
*valid_sigframe(struct KBacktraceIterator
* kbt
)
160 BacktraceIterator
*b
= &kbt
->it
;
162 if (b
->pc
== VDSO_BASE
) {
163 struct rt_sigframe
*frame
;
164 unsigned long sigframe_top
=
165 b
->sp
+ sizeof(struct rt_sigframe
) - 1;
166 if (!valid_address(kbt
, b
->sp
) ||
167 !valid_address(kbt
, sigframe_top
)) {
169 printk(" (odd signal: sp %#lx?)\n",
170 (unsigned long)(b
->sp
));
173 frame
= (struct rt_sigframe
*)b
->sp
;
175 printk(KERN_ERR
" <received signal %d>\n",
176 frame
->info
.si_signo
);
178 return &frame
->uc
.uc_mcontext
.regs
;
183 int KBacktraceIterator_is_sigreturn(struct KBacktraceIterator
*kbt
)
185 return is_sigreturn(kbt
->it
.pc
);
188 static int KBacktraceIterator_restart(struct KBacktraceIterator
*kbt
)
192 p
= valid_fault_handler(kbt
);
194 p
= valid_sigframe(kbt
);
197 backtrace_init(&kbt
->it
, read_memory_func
, kbt
,
198 p
->pc
, p
->lr
, p
->sp
, p
->regs
[52]);
199 kbt
->new_context
= 1;
203 /* Find a frame that isn't a sigreturn, if there is one. */
204 static int KBacktraceIterator_next_item_inclusive(
205 struct KBacktraceIterator
*kbt
)
209 if (!KBacktraceIterator_is_sigreturn(kbt
))
211 } while (backtrace_next(&kbt
->it
));
213 if (!KBacktraceIterator_restart(kbt
))
219 * If the current sp is on a page different than what we recorded
220 * as the top-of-kernel-stack last time we context switched, we have
221 * probably blown the stack, and nothing is going to work out well.
222 * If we can at least get out a warning, that may help the debug,
223 * though we probably won't be able to backtrace into the code that
224 * actually did the recursive damage.
226 static void validate_stack(struct pt_regs
*regs
)
228 int cpu
= smp_processor_id();
229 unsigned long ksp0
= get_current_ksp0();
230 unsigned long ksp0_base
= ksp0
- THREAD_SIZE
;
231 unsigned long sp
= stack_pointer
;
233 if (EX1_PL(regs
->ex1
) == KERNEL_PL
&& regs
->sp
>= ksp0
) {
234 printk("WARNING: cpu %d: kernel stack page %#lx underrun!\n"
235 " sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
236 cpu
, ksp0_base
, sp
, regs
->sp
, regs
->pc
, regs
->lr
);
239 else if (sp
< ksp0_base
+ sizeof(struct thread_info
)) {
240 printk("WARNING: cpu %d: kernel stack page %#lx overrun!\n"
241 " sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
242 cpu
, ksp0_base
, sp
, regs
->sp
, regs
->pc
, regs
->lr
);
246 void KBacktraceIterator_init(struct KBacktraceIterator
*kbt
,
247 struct task_struct
*t
, struct pt_regs
*regs
)
249 VirtualAddress pc
, lr
, sp
, r52
;
253 * Set up callback information. We grab the kernel stack base
254 * so we will allow reads of that address range, and if we're
255 * asking about the current process we grab the page table
256 * so we can check user accesses before trying to read them.
257 * We flush the TLB to avoid any weird skew issues.
259 is_current
= (t
== NULL
);
260 kbt
->is_current
= is_current
;
262 t
= validate_current();
265 kbt
->verbose
= 0; /* override in caller if desired */
266 kbt
->profile
= 0; /* override in caller if desired */
268 kbt
->new_context
= 0;
270 HV_PhysAddr pgdir_pa
= hv_inquire_context().page_table
;
271 if (pgdir_pa
== (unsigned long)swapper_pg_dir
- PAGE_OFFSET
) {
273 * Not just an optimization: this also allows
274 * this to work at all before va/pa mappings
277 kbt
->pgtable
= swapper_pg_dir
;
279 struct page
*page
= pfn_to_page(PFN_DOWN(pgdir_pa
));
280 if (!PageHighMem(page
))
281 kbt
->pgtable
= __va(pgdir_pa
);
283 printk(KERN_ERR
"page table not in LOWMEM"
284 " (%#llx)\n", pgdir_pa
);
286 local_flush_tlb_all();
287 validate_stack(regs
);
291 extern const void *get_switch_to_pc(void);
292 if (is_current
|| t
->state
== TASK_RUNNING
) {
293 /* Can't do this; we need registers */
297 pc
= (ulong
) get_switch_to_pc();
305 r52
= regs
->regs
[52];
308 backtrace_init(&kbt
->it
, read_memory_func
, kbt
, pc
, lr
, sp
, r52
);
309 kbt
->end
= !KBacktraceIterator_next_item_inclusive(kbt
);
311 EXPORT_SYMBOL(KBacktraceIterator_init
);
313 int KBacktraceIterator_end(struct KBacktraceIterator
*kbt
)
317 EXPORT_SYMBOL(KBacktraceIterator_end
);
319 void KBacktraceIterator_next(struct KBacktraceIterator
*kbt
)
321 kbt
->new_context
= 0;
322 if (!backtrace_next(&kbt
->it
) &&
323 !KBacktraceIterator_restart(kbt
)) {
328 kbt
->end
= !KBacktraceIterator_next_item_inclusive(kbt
);
330 EXPORT_SYMBOL(KBacktraceIterator_next
);
333 * This method wraps the backtracer's more generic support.
334 * It is only invoked from the architecture-specific code; show_stack()
335 * and dump_stack() (in entry.S) are architecture-independent entry points.
337 void tile_show_stack(struct KBacktraceIterator
*kbt
, int headers
)
343 * Add a blank line since if we are called from panic(),
344 * then bust_spinlocks() spit out a space in front of us
345 * and it will mess up our KERN_ERR.
348 printk(KERN_ERR
"Starting stack dump of tid %d, pid %d (%s)"
349 " on cpu %d at cycle %lld\n",
350 kbt
->task
->pid
, kbt
->task
->tgid
, kbt
->task
->comm
,
351 smp_processor_id(), get_cycles());
354 if (kbt
->is_current
) {
355 __insn_mtspr(SPR_SIM_CONTROL
,
356 SIM_DUMP_SPR_ARG(SIM_DUMP_BACKTRACE
));
361 for (; !KBacktraceIterator_end(kbt
); KBacktraceIterator_next(kbt
)) {
364 unsigned long address
= kbt
->it
.pc
;
365 unsigned long offset
, size
;
366 char namebuf
[KSYM_NAME_LEN
+100];
368 if (address
>= PAGE_OFFSET
)
369 name
= kallsyms_lookup(address
, &size
, &offset
,
377 size_t namelen
= strlen(namebuf
);
378 size_t remaining
= (sizeof(namebuf
) - 1) - namelen
;
379 char *p
= namebuf
+ namelen
;
380 int rc
= snprintf(p
, remaining
, "+%#lx/%#lx ",
382 if (modname
&& rc
< remaining
)
383 snprintf(p
+ rc
, remaining
- rc
,
385 namebuf
[sizeof(namebuf
)-1] = '\0';
388 printk(KERN_ERR
" frame %d: 0x%lx %s(sp 0x%lx)\n",
389 i
++, address
, namebuf
, (unsigned long)(kbt
->it
.sp
));
392 printk(KERN_ERR
"Stack dump truncated"
393 " (%d frames)\n", i
);
398 printk(KERN_ERR
"Stack dump complete\n");
400 EXPORT_SYMBOL(tile_show_stack
);
403 /* This is called from show_regs() and _dump_stack() */
404 void dump_stack_regs(struct pt_regs
*regs
)
406 struct KBacktraceIterator kbt
;
407 KBacktraceIterator_init(&kbt
, NULL
, regs
);
408 tile_show_stack(&kbt
, 1);
410 EXPORT_SYMBOL(dump_stack_regs
);
412 static struct pt_regs
*regs_to_pt_regs(struct pt_regs
*regs
,
413 ulong pc
, ulong lr
, ulong sp
, ulong r52
)
415 memset(regs
, 0, sizeof(struct pt_regs
));
419 regs
->regs
[52] = r52
;
423 /* This is called from dump_stack() and just converts to pt_regs */
424 void _dump_stack(int dummy
, ulong pc
, ulong lr
, ulong sp
, ulong r52
)
427 dump_stack_regs(regs_to_pt_regs(®s
, pc
, lr
, sp
, r52
));
430 /* This is called from KBacktraceIterator_init_current() */
431 void _KBacktraceIterator_init_current(struct KBacktraceIterator
*kbt
, ulong pc
,
432 ulong lr
, ulong sp
, ulong r52
)
435 KBacktraceIterator_init(kbt
, NULL
,
436 regs_to_pt_regs(®s
, pc
, lr
, sp
, r52
));
439 /* This is called only from kernel/sched.c, with esp == NULL */
440 void show_stack(struct task_struct
*task
, unsigned long *esp
)
442 struct KBacktraceIterator kbt
;
443 if (task
== NULL
|| task
== current
)
444 KBacktraceIterator_init_current(&kbt
);
446 KBacktraceIterator_init(&kbt
, task
, NULL
);
447 tile_show_stack(&kbt
, 0);
450 #ifdef CONFIG_STACKTRACE
452 /* Support generic Linux stack API too */
454 void save_stack_trace_tsk(struct task_struct
*task
, struct stack_trace
*trace
)
456 struct KBacktraceIterator kbt
;
457 int skip
= trace
->skip
;
460 if (task
== NULL
|| task
== current
)
461 KBacktraceIterator_init_current(&kbt
);
463 KBacktraceIterator_init(&kbt
, task
, NULL
);
464 for (; !KBacktraceIterator_end(&kbt
); KBacktraceIterator_next(&kbt
)) {
469 if (i
>= trace
->max_entries
|| kbt
.it
.pc
< PAGE_OFFSET
)
471 trace
->entries
[i
++] = kbt
.it
.pc
;
473 trace
->nr_entries
= i
;
475 EXPORT_SYMBOL(save_stack_trace_tsk
);
477 void save_stack_trace(struct stack_trace
*trace
)
479 save_stack_trace_tsk(NULL
, trace
);
485 EXPORT_SYMBOL(KBacktraceIterator_init_current
);