stack.c

/* -*- linux-c -*- */

#ifdef __x86_64__
/* ripped out of arch/x86_64/kernel/traps.c */
#include <linux/kallsyms.h> 

static int _stp_printk_address(unsigned long address)
{ 
        unsigned long offset = 0, symsize;
        const char *symname;
        char *modname;
        char *delim = ":"; 
        char namebuf[128];
        
        symname = _stp_kallsyms_lookup(address, &symsize, &offset, &modname, namebuf); 
        if (!symname) 
                return printk("[<%016lx>]", address);
        if (!modname)
                modname = delim = "";           
        return printk("<%016lx>{%s%s%s%s%+ld}",
                      address,delim,modname,delim,symname,offset); 
}

void _stp_show_trace(unsigned long *stack)
{
        unsigned long addr;
        unsigned long *irqstack, *irqstack_end, *estack_end;
        const int cpu = safe_smp_processor_id();
        int i;

        printk("\nCall Trace:");
        i = 0; 
        
        estack_end = in_exception_stack(cpu, (unsigned long)stack); 
        if (estack_end) { 
                while (stack < estack_end) { 
                        addr = *stack++; 
                        if (__kernel_text_address(addr)) {
                                i += printk_address(addr);
                                i += printk(" "); 
                                if (i > 50) {
                                        printk("\n"); 
                                        i = 0;
                                }
                        }
                }
                i += printk(" <EOE> "); 
                i += 7;
                stack = (unsigned long *) estack_end[-2]; 
        }  

        irqstack_end = (unsigned long *) (cpu_pda[cpu].irqstackptr);
        irqstack = (unsigned long *) (cpu_pda[cpu].irqstackptr - IRQSTACKSIZE + 64);

        if (stack >= irqstack && stack < irqstack_end) {
                printk("<IRQ> ");  
                while (stack < irqstack_end) {
                        addr = *stack++;
                        /*
                         * 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)) {
                                 i += printk_address(addr);
                                 i += printk(" "); 
                                 if (i > 50) { 
                                        printk("\n       ");
                                         i = 0;
                                 } 
                        }
                } 
                stack = (unsigned long *) (irqstack_end[-1]);
                printk(" <EOI> ");
                i += 7;
        } 

        while (((long) stack & (THREAD_SIZE-1)) != 0) {
                addr = *stack++;
                if (__kernel_text_address(addr)) {
                        i += printk_address(addr);
                        i += printk(" "); 
                        if (i > 50) { 
                                printk("\n       ");
                                         i = 0;
                        } 
                }
        }
        printk("\n");
}

void _stp_dump_stack(void)
{
  unsigned long dummy;
  show_trace(&dummy);
}

#else  /* i386 */

static inline int valid_stack_ptr(struct thread_info *tinfo, void *p)
{
        return  p > (void *)tinfo &&
                p < (void *)tinfo + THREAD_SIZE - 3;
}

int __kernel_text_address(unsigned long addr)
{
        if (core_kernel_text(addr))
                return 1;
        return __module_text_address(addr) != NULL;
}

static inline unsigned long _stp_print_context_stack(struct thread_info *tinfo,
                                unsigned long *stack, unsigned long ebp)
{
        unsigned long addr;

#ifdef  CONFIG_FRAME_POINTER
        while (valid_stack_ptr(tinfo, (void *)ebp)) {
                addr = *(unsigned long *)(ebp + 4);
                _stp_print_buf(" [<%08lx>] ", addr);
                _stp_print_symbol("%s", addr);
                _stp_print_buf("\n");
                ebp = *(unsigned long *)ebp;
        }
#else
        while (valid_stack_ptr(tinfo, stack)) {
                addr = *stack++;
                if (__kernel_text_address(addr)) {
                        _stp_print_buf(" [<%08lx>]", addr);
                        _stp_print_symbol(" %s", addr);
                        _stp_print_buf("\n");
                }
        }
#endif
        return ebp;
}

void show_trace(struct task_struct *task, unsigned long * stack)
{
        unsigned long ebp;

        if (!task)
                task = current;

        if (task == current) {
                /* Grab ebp right from our regs */
                asm ("movl %%ebp, %0" : "=r" (ebp) : );
        } else {
                /* ebp is the last reg pushed by switch_to */
                ebp = *(unsigned long *) task->thread.esp;
        }

        while (1) {
                struct thread_info *context;
                context = (struct thread_info *)
                        ((unsigned long)stack & (~(THREAD_SIZE - 1)));
                ebp = _stp_print_context_stack(context, stack, ebp);
                stack = (unsigned long*)context->previous_esp;
                if (!stack)
                        break;
                _stp_print_buf(" =======================\n");
        }
}

void dump_stack(void)
{
        unsigned long stack;
        show_trace(current, &stack);
}
#endif

---