arch/arc/kernel/stacktrace.c - kernel/skids - Git at Google

 /*
  * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  *              Stack tracing for ARC Linux
  *
  *  vineetg: aug 2009
  *  -Implemented CONFIG_STACKTRACE APIs, primarily save_stack_trace_tsk( )
  *   for displaying task's kernel mode call stack in /proc/<pid>/stack
  *  -Iterator based approach to have single copy of unwinding core and APIs
  *   needing unwinding, implement the logic in iterator regarding:
  *      = which frame onwards to start capture
  *      = which frame to stop capturing (wchan)
  *      = specifics of data structs where trace is saved(CONFIG_STACKTRACE etc)
  *
  *  vineetg: March 2009
  *  -Implemented correct versions of thread_saved_pc() and get_wchan()
  *
  *  rajeshwarr: 2008
  *  -Initial implementation
  */

 #include <linux/ptrace.h>
 #include <linux/module.h>
 #include <asm/arcregs.h>
 #include <asm/unwind.h>
 #include <linux/stacktrace.h>
 #include <linux/kallsyms.h>

 #define CRASH_MAX_ENTRIES	16
 #define CRASH_SYM_LEN		64
 struct crash_stack_trace {
 	int num_entries;
 	struct {
 		unsigned int addr;
 		char sym[KSYM_SYMBOL_LEN];
 	} e [CRASH_MAX_ENTRIES];
 };

 struct crash_stack_trace crash_log;

 /*-------------------------------------------------------------------------
  *              Unwinding Core
  *-------------------------------------------------------------------------
  */
 #ifdef CONFIG_ARC_STACK_UNWIND

 static void seed_unwind_frame_info(struct task_struct *tsk,
     struct pt_regs *regs, struct unwind_frame_info *frame_info)
 {
     if (tsk == NULL && regs == NULL)
     {
         unsigned long fp, sp, blink, ret;
         frame_info->task = current;

         __asm__ __volatile__(
                   "1:mov %0,r27\n\t"
                     "mov %1,r28\n\t"
                     "mov %2,r31\n\t"
                     "mov %3,r63\n\t"
                    :"=r"(fp),"=r"(sp),"=r"(blink),"=r"(ret)
                    :
                    );

         frame_info->regs.r27 = fp;
         frame_info->regs.r28 = sp;
         frame_info->regs.r31 = blink;
         frame_info->regs.r63 = ret;
         frame_info->call_frame = 0;
     }
     else if (regs == NULL ) {

         frame_info->task = tsk;

         frame_info->regs.r27 = KSTK_FP(tsk);
         frame_info->regs.r28 = KSTK_ESP(tsk);
         frame_info->regs.r31 = KSTK_BLINK(tsk);
         frame_info->regs.r63 = (unsigned int )__switch_to;

         /* In the prologue of __switch_to, first fp is saved on the stack and
          * then sp is copied to fp, the dwarf assumes cfa as fp based but we
          * didn't save fp. The value retrieved above is  the fp's state in previous
          * frame. As a work around for this, we are unwinding from __switch_to
          * address and adjusting the sp accordingly. The other limitaion in
          * __switch_to macro is dwarf rules are not generated for inline
          * assembly code
          */
         frame_info->regs.r27 = 0;
         frame_info->regs.r28 += 64;
         frame_info->call_frame = 0;

     }
     else {
         frame_info->task = tsk;

         frame_info->regs.r27 = regs->fp;
         frame_info->regs.r28 = regs->sp;
         frame_info->regs.r31 = regs->blink;
         frame_info->regs.r63 = regs->ret;
         frame_info->call_frame = 0;
     }
 }

 static unsigned int noinline arc_unwind_core(struct task_struct *tsk,
     struct pt_regs *regs, int (*consumer_fn)(unsigned int, void *), void *arg)
 {
     int ret = 0;
     unsigned int address;
     struct unwind_frame_info frame_info;

     seed_unwind_frame_info(tsk, regs, &frame_info);

     while(1)
     {
         address = UNW_PC(&frame_info);

         if (address && __kernel_text_address(address )) {
             if (consumer_fn(address, arg) == -1 )
                 break;
         }

         ret = arc_unwind(&frame_info);

         if(ret == 0) {
             frame_info.regs.r63 = frame_info.regs.r31;
             continue;
         }
         else {
             break;
         }
     }

     return address; // return the last address it saw
 }

 #else
 static unsigned int arc_unwind_core(struct task_struct *tsk,
     struct pt_regs *regs, int (*fn)(unsigned int, void *),void *arg)
 {
     /* On ARC, only Dward based unwinder works. fp based backtracing is
      * not possible (-fno-omit-frame-pointer) because of the way function
      * prelogue is setup (callee regs saved and then fp set and not other
      * way around
      */
     printk("CONFIG_ARC_STACK_UNWIND needs to be enabled\n");
     return 0;
 }
 #endif

 /*-------------------------------------------------------------------------
  *  iterators called by unwinding core to implement APIs expected by kernel
  *
  *  Return value protocol:
  *      (-1) to stop unwinding
  *      (xx) continue unwinding
  *-------------------------------------------------------------------------
  */

 void save_crash_log(unsigned int address)
 {
     unsigned long flags;
     int count;

     local_irq_save(flags);

     count = crash_log.num_entries;
     if (count < CRASH_MAX_ENTRIES-1) {
 	crash_log.e[count].addr = address;
 	sprint_symbol(crash_log.e[count].sym, address);
 	crash_log.num_entries++;
     }

     local_irq_restore(flags);
 }
 /* Call-back which plugs into unwinding core to dump the stack in
  * case of panic/OOPs/BUG etc
  */
 int verbose_dump_stack(unsigned int address, void *unused)
 {
     printk("  0x%08x ", address);
     __print_symbol("  %s\n", address);
     save_crash_log(address);
     return 0;
 }

 #ifdef CONFIG_STACKTRACE

 /* Call-back which plugs into unwinding core to capture the
  * traces needed by kernel on /proc/<pid>/stack
  */
 int fill_backtrace(unsigned int address, void *arg)
 {
     struct stack_trace *trace = arg;

     if (trace->skip > 0)
         trace->skip--;
     else
         trace->entries[trace->nr_entries++] = address;

     if (trace->nr_entries >= trace->max_entries)
         return -1;

     return 0;
 }

 int fill_backtrace_nosched(unsigned int address, void *arg)
 {
     struct stack_trace *trace = arg;

     if (in_sched_functions(address))
         return 0;

     if (trace->skip > 0)
         trace->skip--;
     else
         trace->entries[trace->nr_entries++] = address;

     if (trace->nr_entries >= trace->max_entries)
         return -1;

     return 0;
 }

 #endif

 int get_first_nonsched_frame(unsigned int address, void *unused)
 {
     if (in_sched_functions(address))
         return 0;

     return -1;
 }

 /*-------------------------------------------------------------------------
  *              APIs expected by various kernel sub-systems
  *-------------------------------------------------------------------------
  */
 void (*g_qtn_show_info) (void) = NULL;

 void qtn_show_info_register(void *fn) {
     g_qtn_show_info = fn;
 }

 void qtn_show_info_unregister(void) {
     g_qtn_show_info = NULL;
 }

 EXPORT_SYMBOL(qtn_show_info_register);
 EXPORT_SYMBOL(qtn_show_info_unregister);

 void noinline show_stacktrace(struct task_struct *tsk, struct pt_regs *regs)
 {
     if (g_qtn_show_info) {
         g_qtn_show_info();
     }
     printk("\nStack Trace:\n");
     arc_unwind_core(tsk, regs, verbose_dump_stack, NULL);
 }

 EXPORT_SYMBOL(show_stacktrace);

 /* Expected by sched Code */
 void show_stack(struct task_struct *tsk, unsigned long *sp)
 {
     show_stacktrace(tsk, NULL);
 }

 /* Expected by Rest of kernel code */
 void dump_stack(void)
 {
     show_stacktrace(0, NULL);
 }

 EXPORT_SYMBOL(dump_stack);

 /* Another API expected by schedular, shows up in "ps" as Wait Channel
  * Ofcourse just returning schedule( ) would be pointless so unwind until
  * the function is not in schedular code
  */
 unsigned int get_wchan(struct task_struct *tsk)
 {
     return arc_unwind_core(tsk, NULL, get_first_nonsched_frame, NULL);
 }

 #ifdef CONFIG_STACKTRACE

 /* API required by CONFIG_STACKTRACE, CONFIG_LATENCYTOP.
  * A typical use is when /proc/<pid>/stack is queried by userland
  * and also by LatencyTop
  */
 void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
 {
     arc_unwind_core(tsk, NULL, fill_backtrace_nosched, trace);
 }

 void save_stack_trace(struct stack_trace *trace)
 {
     arc_unwind_core(current, NULL, fill_backtrace, trace);
 }
 #endif
	/*
	* Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*
	* Stack tracing for ARC Linux
	*
	* vineetg: aug 2009
	* -Implemented CONFIG_STACKTRACE APIs, primarily save_stack_trace_tsk( )
	* for displaying task's kernel mode call stack in /proc/<pid>/stack
	* -Iterator based approach to have single copy of unwinding core and APIs
	* needing unwinding, implement the logic in iterator regarding:
	* = which frame onwards to start capture
	* = which frame to stop capturing (wchan)
	* = specifics of data structs where trace is saved(CONFIG_STACKTRACE etc)
	*
	* vineetg: March 2009
	* -Implemented correct versions of thread_saved_pc() and get_wchan()
	*
	* rajeshwarr: 2008
	* -Initial implementation
	*/

	#include <linux/ptrace.h>
	#include <linux/module.h>
	#include <asm/arcregs.h>
	#include <asm/unwind.h>
	#include <linux/stacktrace.h>
	#include <linux/kallsyms.h>

	#define CRASH_MAX_ENTRIES 16
	#define CRASH_SYM_LEN 64
	struct crash_stack_trace {
	int num_entries;
	struct {
	unsigned int addr;
	char sym[KSYM_SYMBOL_LEN];
	} e [CRASH_MAX_ENTRIES];
	};

	struct crash_stack_trace crash_log;

	/*-------------------------------------------------------------------------
	* Unwinding Core
	*-------------------------------------------------------------------------
	*/
	#ifdef CONFIG_ARC_STACK_UNWIND

	static void seed_unwind_frame_info(struct task_struct *tsk,
	struct pt_regs regs, struct unwind_frame_info frame_info)
	{
	if (tsk == NULL && regs == NULL)
	{
	unsigned long fp, sp, blink, ret;
	frame_info->task = current;

	__asm__ __volatile__(
	"1:mov %0,r27\n\t"
	"mov %1,r28\n\t"
	"mov %2,r31\n\t"
	"mov %3,r63\n\t"
	:"=r"(fp),"=r"(sp),"=r"(blink),"=r"(ret)
	:
	);

	frame_info->regs.r27 = fp;
	frame_info->regs.r28 = sp;
	frame_info->regs.r31 = blink;
	frame_info->regs.r63 = ret;
	frame_info->call_frame = 0;
	}
	else if (regs == NULL ) {

	frame_info->task = tsk;

	frame_info->regs.r27 = KSTK_FP(tsk);
	frame_info->regs.r28 = KSTK_ESP(tsk);
	frame_info->regs.r31 = KSTK_BLINK(tsk);
	frame_info->regs.r63 = (unsigned int )__switch_to;

	/* In the prologue of __switch_to, first fp is saved on the stack and
	* then sp is copied to fp, the dwarf assumes cfa as fp based but we
	* didn't save fp. The value retrieved above is the fp's state in previous
	* frame. As a work around for this, we are unwinding from __switch_to
	* address and adjusting the sp accordingly. The other limitaion in
	* __switch_to macro is dwarf rules are not generated for inline
	* assembly code
	*/
	frame_info->regs.r27 = 0;
	frame_info->regs.r28 += 64;
	frame_info->call_frame = 0;

	}
	else {
	frame_info->task = tsk;

	frame_info->regs.r27 = regs->fp;
	frame_info->regs.r28 = regs->sp;
	frame_info->regs.r31 = regs->blink;
	frame_info->regs.r63 = regs->ret;
	frame_info->call_frame = 0;
	}
	}

	static unsigned int noinline arc_unwind_core(struct task_struct *tsk,
	struct pt_regs regs, int (consumer_fn)(unsigned int, void ), void arg)
	{
	int ret = 0;
	unsigned int address;
	struct unwind_frame_info frame_info;

	seed_unwind_frame_info(tsk, regs, &frame_info);

	while(1)
	{
	address = UNW_PC(&frame_info);

	if (address && __kernel_text_address(address )) {
	if (consumer_fn(address, arg) == -1 )
	break;
	}

	ret = arc_unwind(&frame_info);

	if(ret == 0) {
	frame_info.regs.r63 = frame_info.regs.r31;
	continue;
	}
	else {
	break;
	}
	}

	return address; // return the last address it saw
	}

	#else
	static unsigned int arc_unwind_core(struct task_struct *tsk,
	struct pt_regs regs, int (fn)(unsigned int, void ),void arg)
	{
	/* On ARC, only Dward based unwinder works. fp based backtracing is
	* not possible (-fno-omit-frame-pointer) because of the way function
	* prelogue is setup (callee regs saved and then fp set and not other
	* way around
	*/
	printk("CONFIG_ARC_STACK_UNWIND needs to be enabled\n");
	return 0;
	}
	#endif

	/*-------------------------------------------------------------------------
	* iterators called by unwinding core to implement APIs expected by kernel
	*
	* Return value protocol:
	* (-1) to stop unwinding
	* (xx) continue unwinding
	*-------------------------------------------------------------------------
	*/

	void save_crash_log(unsigned int address)
	{
	unsigned long flags;
	int count;

	local_irq_save(flags);

	count = crash_log.num_entries;
	if (count < CRASH_MAX_ENTRIES-1) {
	crash_log.e[count].addr = address;
	sprint_symbol(crash_log.e[count].sym, address);
	crash_log.num_entries++;
	}

	local_irq_restore(flags);
	}
	/* Call-back which plugs into unwinding core to dump the stack in
	* case of panic/OOPs/BUG etc
	*/
	int verbose_dump_stack(unsigned int address, void *unused)
	{
	printk(" 0x%08x ", address);
	__print_symbol(" %s\n", address);
	save_crash_log(address);
	return 0;
	}

	#ifdef CONFIG_STACKTRACE

	/* Call-back which plugs into unwinding core to capture the
	* traces needed by kernel on /proc/<pid>/stack
	*/
	int fill_backtrace(unsigned int address, void *arg)
	{
	struct stack_trace *trace = arg;

	if (trace->skip > 0)
	trace->skip--;
	else
	trace->entries[trace->nr_entries++] = address;

	if (trace->nr_entries >= trace->max_entries)
	return -1;

	return 0;
	}

	int fill_backtrace_nosched(unsigned int address, void *arg)
	{
	struct stack_trace *trace = arg;

	if (in_sched_functions(address))
	return 0;

	if (trace->skip > 0)
	trace->skip--;
	else
	trace->entries[trace->nr_entries++] = address;

	if (trace->nr_entries >= trace->max_entries)
	return -1;

	return 0;
	}

	#endif

	int get_first_nonsched_frame(unsigned int address, void *unused)
	{
	if (in_sched_functions(address))
	return 0;

	return -1;
	}

	/*-------------------------------------------------------------------------
	* APIs expected by various kernel sub-systems
	*-------------------------------------------------------------------------
	*/
	void (*g_qtn_show_info) (void) = NULL;

	void qtn_show_info_register(void *fn) {
	g_qtn_show_info = fn;
	}

	void qtn_show_info_unregister(void) {
	g_qtn_show_info = NULL;
	}

	EXPORT_SYMBOL(qtn_show_info_register);
	EXPORT_SYMBOL(qtn_show_info_unregister);

	void noinline show_stacktrace(struct task_struct tsk, struct pt_regs regs)
	{
	if (g_qtn_show_info) {
	g_qtn_show_info();
	}
	printk("\nStack Trace:\n");
	arc_unwind_core(tsk, regs, verbose_dump_stack, NULL);
	}

	EXPORT_SYMBOL(show_stacktrace);

	/* Expected by sched Code */
	void show_stack(struct task_struct tsk, unsigned long sp)
	{
	show_stacktrace(tsk, NULL);
	}

	/* Expected by Rest of kernel code */
	void dump_stack(void)
	{
	show_stacktrace(0, NULL);
	}

	EXPORT_SYMBOL(dump_stack);

	/* Another API expected by schedular, shows up in "ps" as Wait Channel
	* Ofcourse just returning schedule( ) would be pointless so unwind until
	* the function is not in schedular code
	*/
	unsigned int get_wchan(struct task_struct *tsk)
	{
	return arc_unwind_core(tsk, NULL, get_first_nonsched_frame, NULL);
	}

	#ifdef CONFIG_STACKTRACE

	/* API required by CONFIG_STACKTRACE, CONFIG_LATENCYTOP.
	* A typical use is when /proc/<pid>/stack is queried by userland
	* and also by LatencyTop
	*/
	void save_stack_trace_tsk(struct task_struct tsk, struct stack_trace trace)
	{
	arc_unwind_core(tsk, NULL, fill_backtrace_nosched, trace);
	}

	void save_stack_trace(struct stack_trace *trace)
	{
	arc_unwind_core(current, NULL, fill_backtrace, trace);
	}
	#endif