Skip to content

Commit

Permalink
Blackfin arch: Add unwinding for stack info, and a little more detail…
Browse files Browse the repository at this point in the history 
… on trace buffer

Signed-off-by: Robin Getz <rgetz@blackfin.uclinux.org>
Signed-off-by: Bryan Wu <cooloney@kernel.org>
  • Loading branch information
Robin Getz authored and Bryan Wu committed Jul 26, 2008
1 parent 0a6304a commit f09630b
Showing 1 changed file with 241 additions and 55 deletions.
296 changes: 241 additions & 55 deletions arch/blackfin/kernel/traps.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -69,8 +69,6 @@ void __init trap_init(void)

unsigned long saved_icplb_fault_addr, saved_dcplb_fault_addr;

int kstack_depth_to_print = 48;

static void decode_address(char *buf, unsigned long address)
{
struct vm_list_struct *vml;
Expand Down Expand Up @@ -163,6 +161,9 @@ static void decode_address(char *buf, unsigned long address)
if (!in_atomic)
mmput(mm);

if (!strlen(buf))
sprintf(buf, "<0x%p> [ %s ] dynamic memory", (void *)address, name);

goto done;
}

Expand All @@ -173,7 +174,7 @@ static void decode_address(char *buf, unsigned long address)
}

/* we were unable to find this address anywhere */
sprintf(buf, "<0x%p> /* unknown address */", (void *)address);
sprintf(buf, "<0x%p> /* kernel dynamic memory */", (void *)address);

done:
write_unlock_irqrestore(&tasklist_lock, flags);
Expand Down Expand Up @@ -494,7 +495,7 @@ asmlinkage void trap_c(struct pt_regs *fp)
BUG_ON(sig == 0);

if (sig != SIGTRAP) {
unsigned long stack;
unsigned long *stack;
dump_bfin_process(fp);
dump_bfin_mem(fp);
show_regs(fp);
Expand All @@ -508,14 +509,23 @@ asmlinkage void trap_c(struct pt_regs *fp)
else
#endif
dump_bfin_trace_buffer();
show_stack(current, &stack);

if (oops_in_progress) {
/* Dump the current kernel stack */
printk(KERN_NOTICE "\n" KERN_NOTICE "Kernel Stack\n");
show_stack(current, NULL);

print_modules();
#ifndef CONFIG_ACCESS_CHECK
printk(KERN_EMERG "Please turn on "
"CONFIG_ACCESS_CHECK\n");
#endif
panic("Kernel exception");
} else {
/* Dump the user space stack */
stack = (unsigned long *)rdusp();
printk(KERN_NOTICE "Userspace Stack\n");
show_stack(NULL, stack);
}
}

Expand All @@ -532,11 +542,71 @@ asmlinkage void trap_c(struct pt_regs *fp)

#define EXPAND_LEN ((1 << CONFIG_DEBUG_BFIN_HWTRACE_EXPAND_LEN) * 256 - 1)

/*
* Similar to get_user, do some address checking, then dereference
* Return true on sucess, false on bad address
*/
bool get_instruction(unsigned short *val, unsigned short *address)
{

unsigned long addr;

addr = (unsigned long)address;

/* Check for odd addresses */
if (addr & 0x1)
return false;

/* Check that things do not wrap around */
if (addr > (addr + 2))
return false;

/*
* Since we are in exception context, we need to do a little address checking
* We need to make sure we are only accessing valid memory, and
* we don't read something in the async space that can hang forever
*/
if ((addr >= FIXED_CODE_START && (addr + 2) <= physical_mem_end) ||
#ifdef L2_START
(addr >= L2_START && (addr + 2) <= (L2_START + L2_LENGTH)) ||
#endif
(addr >= BOOT_ROM_START && (addr + 2) <= (BOOT_ROM_START + BOOT_ROM_LENGTH)) ||
#if L1_DATA_A_LENGTH != 0
(addr >= L1_DATA_A_START && (addr + 2) <= (L1_DATA_A_START + L1_DATA_A_LENGTH)) ||
#endif
#if L1_DATA_B_LENGTH != 0
(addr >= L1_DATA_B_START && (addr + 2) <= (L1_DATA_B_START + L1_DATA_B_LENGTH)) ||
#endif
(addr >= L1_SCRATCH_START && (addr + 2) <= (L1_SCRATCH_START + L1_SCRATCH_LENGTH)) ||
(!(bfin_read_EBIU_AMBCTL0() & B0RDYEN) &&
addr >= ASYNC_BANK0_BASE && (addr + 2) <= (ASYNC_BANK0_BASE + ASYNC_BANK0_SIZE)) ||
(!(bfin_read_EBIU_AMBCTL0() & B1RDYEN) &&
addr >= ASYNC_BANK1_BASE && (addr + 2) <= (ASYNC_BANK1_BASE + ASYNC_BANK1_SIZE)) ||
(!(bfin_read_EBIU_AMBCTL1() & B2RDYEN) &&
addr >= ASYNC_BANK2_BASE && (addr + 2) <= (ASYNC_BANK2_BASE + ASYNC_BANK1_SIZE)) ||
(!(bfin_read_EBIU_AMBCTL1() & B3RDYEN) &&
addr >= ASYNC_BANK3_BASE && (addr + 2) <= (ASYNC_BANK3_BASE + ASYNC_BANK1_SIZE))) {
*val = *address;
return true;
}

#if L1_CODE_LENGTH != 0
if (addr >= L1_CODE_START && (addr + 2) <= (L1_CODE_START + L1_CODE_LENGTH)) {
dma_memcpy(val, address, 2);
return true;
}
#endif


return false;
}

void dump_bfin_trace_buffer(void)
{
#ifdef CONFIG_DEBUG_BFIN_HWTRACE_ON
int tflags, i = 0;
char buf[150];
unsigned short val = 0, *addr;
#ifdef CONFIG_DEBUG_BFIN_HWTRACE_EXPAND
int j, index;
#endif
Expand All @@ -549,8 +619,42 @@ void dump_bfin_trace_buffer(void)
for (; bfin_read_TBUFSTAT() & TBUFCNT; i++) {
decode_address(buf, (unsigned long)bfin_read_TBUF());
printk(KERN_NOTICE "%4i Target : %s\n", i, buf);
decode_address(buf, (unsigned long)bfin_read_TBUF());
printk(KERN_NOTICE " Source : %s\n", buf);
addr = (unsigned short *)bfin_read_TBUF();
decode_address(buf, (unsigned long)addr);
printk(KERN_NOTICE " Source : %s ", buf);
if (get_instruction(&val, addr)) {
if (val == 0x0010)
printk("RTS");
else if (val == 0x0011)
printk("RTI");
else if (val == 0x0012)
printk("RTX");
else if (val >= 0x0050 && val <= 0x0057)
printk("JUMP (P%i)", val & 7);
else if (val >= 0x0060 && val <= 0x0067)
printk("CALL (P%i)", val & 7);
else if (val >= 0x0070 && val <= 0x0077)
printk("CALL (PC+P%i)", val & 7);
else if (val >= 0x0080 && val <= 0x0087)
printk("JUMP (PC+P%i)", val & 7);
else if ((val >= 0x1000 && val <= 0x13FF) ||
(val >= 0x1800 && val <= 0x1BFF))
printk("IF !CC JUMP");
else if ((val >= 0x1400 && val <= 0x17ff) ||
(val >= 0x1c00 && val <= 0x1fff))
printk("IF CC JUMP");
else if (val >= 0x2000 && val <= 0x2fff)
printk("JUMP.S");
else if (val >= 0xe080 && val <= 0xe0ff)
printk("LSETUP");
else if (val >= 0xe200 && val <= 0xe2ff)
printk("JUMP.L");
else if (val >= 0xe300 && val <= 0xe3ff)
printk("CALL pcrel");
else
printk("0x%04x", val);
}
printk("\n");
}
}

Expand Down Expand Up @@ -582,59 +686,151 @@ void dump_bfin_trace_buffer(void)
}
EXPORT_SYMBOL(dump_bfin_trace_buffer);

static void show_trace(struct task_struct *tsk, unsigned long *sp)
/*
* Checks to see if the address pointed to is either a
* 16-bit CALL instruction, or a 32-bit CALL instruction
*/
bool is_bfin_call(unsigned short *addr)
{
unsigned long addr;
unsigned short opcode = 0, *ins_addr;
ins_addr = (unsigned short *)addr;

printk(KERN_NOTICE "\n" KERN_NOTICE "Call Trace:\n");

while (!kstack_end(sp)) {
addr = *sp++;
/*
* If the address is either in the text segment of the
* kernel, or in the region which contains vmalloc'ed
* memory, it *may* be the address of a calling
* routine; if so, print it so that someone tracing
* down the cause of the crash will be able to figure
* out the call path that was taken.
*/
if (kernel_text_address(addr))
print_ip_sym(addr);
}
if (!get_instruction(&opcode, ins_addr))
return false;

printk(KERN_NOTICE "\n");
}
if ((opcode >= 0x0060 && opcode <= 0x0067) ||
(opcode >= 0x0070 && opcode <= 0x0077))
return true;

ins_addr--;
if (!get_instruction(&opcode, ins_addr))
return false;

if (opcode >= 0xE300 && opcode <= 0xE3FF)
return true;

return false;

}
void show_stack(struct task_struct *task, unsigned long *stack)
{
unsigned long *endstack, addr;
int i;
unsigned int *addr, *endstack, *fp = 0, *frame;
unsigned short *ins_addr;
char buf[150];
unsigned int i, j, ret_addr, frame_no = 0;

/* Cannot call dump_bfin_trace_buffer() here as show_stack() is
* called externally in some places in the kernel.
/*
* If we have been passed a specific stack, use that one otherwise
* if we have been passed a task structure, use that, otherwise
* use the stack of where the variable "stack" exists
*/

if (!stack) {
if (task)
if (stack == NULL) {
if (task) {
/* We know this is a kernel stack, so this is the start/end */
stack = (unsigned long *)task->thread.ksp;
else
endstack = (unsigned int *)(((unsigned int)(stack) & ~(THREAD_SIZE - 1)) + THREAD_SIZE);
} else {
/* print out the existing stack info */
stack = (unsigned long *)&stack;
endstack = (unsigned int *)PAGE_ALIGN((unsigned int)stack);
}
} else
endstack = (unsigned int *)PAGE_ALIGN((unsigned int)stack);

decode_address(buf, (unsigned int)stack);
printk(KERN_NOTICE "Stack info:\n" KERN_NOTICE " SP: [0x%p] %s\n", stack, buf);
addr = (unsigned int *)((unsigned int)stack & ~0x3F);

/* First thing is to look for a frame pointer */
for (addr = (unsigned int *)((unsigned int)stack & ~0xF), i = 0;
addr < endstack; addr++, i++) {
if (*addr & 0x1)
continue;
ins_addr = (unsigned short *)*addr;
ins_addr--;
if (is_bfin_call(ins_addr))
fp = addr - 1;

if (fp) {
/* Let's check to see if it is a frame pointer */
while (fp >= (addr - 1) && fp < endstack && fp)
fp = (unsigned int *)*fp;
if (fp == 0 || fp == endstack) {
fp = addr - 1;
break;
}
fp = 0;
}
}
if (fp) {
frame = fp;
printk(" FP: (0x%p)\n", fp);
} else
frame = 0;

addr = (unsigned long)stack;
endstack = (unsigned long *)PAGE_ALIGN(addr);
/*
* Now that we think we know where things are, we
* walk the stack again, this time printing things out
* incase there is no frame pointer, we still look for
* valid return addresses
*/

printk(KERN_NOTICE "Stack from %08lx:", (unsigned long)stack);
for (i = 0; i < kstack_depth_to_print; i++) {
if (stack + 1 > endstack)
break;
if (i % 8 == 0)
printk("\n" KERN_NOTICE " ");
printk(" %08lx", *stack++);
/* First time print out data, next time, print out symbols */
for (j = 0; j <= 1; j++) {
if (j)
printk(KERN_NOTICE "Return addresses in stack:\n");
else
printk(KERN_NOTICE " Memory from 0x%08lx to %p", ((long unsigned int)stack & ~0xF), endstack);

fp = frame;
frame_no = 0;

for (addr = (unsigned int *)((unsigned int)stack & ~0xF), i = 0;
addr <= endstack; addr++, i++) {

ret_addr = 0;
if (!j && i % 8 == 0)
printk("\n" KERN_NOTICE "%p:",addr);

/* if it is an odd address, or zero, just skip it */
if (*addr & 0x1 || !*addr)
goto print;

ins_addr = (unsigned short *)*addr;

/* Go back one instruction, and see if it is a CALL */
ins_addr--;
ret_addr = is_bfin_call(ins_addr);
print:
if (!j && stack == (unsigned long *)addr)
printk("[%08x]", *addr);
else if (ret_addr)
if (j) {
decode_address(buf, (unsigned int)*addr);
if (frame == addr) {
printk(KERN_NOTICE " frame %2i : %s\n", frame_no, buf);
continue;
}
printk(KERN_NOTICE " address : %s\n", buf);
} else
printk("<%08x>", *addr);
else if (fp == addr) {
if (j)
frame = addr+1;
else
printk("(%08x)", *addr);

fp = (unsigned int *)*addr;
frame_no++;

} else if (!j)
printk(" %08x ", *addr);
}
if (!j)
printk("\n");
}
printk("\n");

show_trace(task, stack);
}

void dump_stack(void)
Expand Down Expand Up @@ -715,19 +911,9 @@ void dump_bfin_mem(struct pt_regs *fp)
if (!((unsigned long)addr & 0xF))
printk("\n" KERN_NOTICE "0x%p: ", addr);

if (get_user(val, addr)) {
if (addr >= (unsigned short *)L1_CODE_START &&
addr < (unsigned short *)(L1_CODE_START + L1_CODE_LENGTH)) {
dma_memcpy(&val, addr, sizeof(val));
sprintf(buf, "%04x", val);
} else if (addr >= (unsigned short *)FIXED_CODE_START &&
addr <= (unsigned short *)memory_start) {
val = bfin_read16(addr);
sprintf(buf, "%04x", val);
} else {
if (get_instruction(&val, addr)) {
val = 0;
sprintf(buf, "????");
}
} else
sprintf(buf, "%04x", val);

Expand Down

0 comments on commit f09630b

Please sign in to comment.