arch/sh/kernel/stacktrace.c

   1 /*
   2  * arch/sh/kernel/stacktrace.c
   3  *
   4  * Stack trace management functions
   5  *
   6  *  Copyright (C) 2006 - 2008  Paul Mundt
   7  *
   8  * This file is subject to the terms and conditions of the GNU General Public
   9  * License.  See the file "COPYING" in the main directory of this archive
  10  * for more details.
  11  */
  12 #include <linux/sched.h>
  13 #include <linux/stacktrace.h>
  14 #include <linux/thread_info.h>
  15 #include <linux/module.h>
  16 #include <asm/unwinder.h>
  17 #include <asm/ptrace.h>
  18 #include <asm/stacktrace.h>
  19
  20 static void save_stack_warning(void *data, char *msg)
  21 {
  22 }
  23
  24 static void
  25 save_stack_warning_symbol(void *data, char *msg, unsigned long symbol)
  26 {
  27 }
  28
  29 static int save_stack_stack(void *data, char *name)
  30 {
  31         return 0;
  32 }
  33
  34 /*
  35  * Save stack-backtrace addresses into a stack_trace buffer.
  36  */
  37 static void save_stack_address(void *data, unsigned long addr, int reliable)
  38 {
  39         struct stack_trace *trace = data;
  40
  41         if (!reliable)
  42                 return;
  43
  44         if (trace->skip > 0) {
  45                 trace->skip--;
  46                 return;
  47         }
  48
  49         if (trace->nr_entries < trace->max_entries)
  50                 trace->entries[trace->nr_entries++] = addr;
  51 }
  52
  53 static const struct stacktrace_ops save_stack_ops = {
  54         .warning = save_stack_warning,
  55         .warning_symbol = save_stack_warning_symbol,
  56         .stack = save_stack_stack,
  57         .address = save_stack_address,
  58 };
  59
  60 void save_stack_trace(struct stack_trace *trace)
  61 {
  62         unsigned long *sp = (unsigned long *)current_stack_pointer;
  63
  64         unwind_stack(current, NULL, sp,  &save_stack_ops, trace);
  65         if (trace->nr_entries < trace->max_entries)
  66                 trace->entries[trace->nr_entries++] = ULONG_MAX;
  67 }
  68 EXPORT_SYMBOL_GPL(save_stack_trace);
  69
  70 static void
  71 save_stack_address_nosched(void *data, unsigned long addr, int reliable)
  72 {
  73         struct stack_trace *trace = (struct stack_trace *)data;
  74
  75         if (!reliable)
  76                 return;
  77
  78         if (in_sched_functions(addr))
  79                 return;
  80
  81         if (trace->skip > 0) {
  82                 trace->skip--;
  83                 return;
  84         }
  85
  86         if (trace->nr_entries < trace->max_entries)
  87                 trace->entries[trace->nr_entries++] = addr;
  88 }
  89
  90 static const struct stacktrace_ops save_stack_ops_nosched = {
  91         .warning = save_stack_warning,
  92         .warning_symbol = save_stack_warning_symbol,
  93         .stack = save_stack_stack,
  94         .address = save_stack_address_nosched,
  95 };
  96
  97 void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
  98 {
  99         unsigned long *sp = (unsigned long *)tsk->thread.sp;
 100
 101         unwind_stack(current, NULL, sp,  &save_stack_ops_nosched, trace);
 102         if (trace->nr_entries < trace->max_entries)
 103                 trace->entries[trace->nr_entries++] = ULONG_MAX;
 104 }
 105 EXPORT_SYMBOL_GPL(save_stack_trace_tsk);