Paul Gortmaker | ecea4ab | 2011-07-22 10:58:34 -0400 | [diff] [blame] | 1 | #include <linux/export.h> |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 2 | #include <linux/sched.h> |
| 3 | #include <linux/stacktrace.h> |
| 4 | |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 5 | #include <asm/stacktrace.h> |
Russell King | 07b4034 | 2014-05-03 16:17:16 +0100 | [diff] [blame] | 6 | #include <asm/traps.h> |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 7 | |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 8 | #if defined(CONFIG_FRAME_POINTER) && !defined(CONFIG_ARM_UNWIND) |
| 9 | /* |
| 10 | * Unwind the current stack frame and store the new register values in the |
| 11 | * structure passed as argument. Unwinding is equivalent to a function return, |
| 12 | * hence the new PC value rather than LR should be used for backtrace. |
| 13 | * |
| 14 | * With framepointer enabled, a simple function prologue looks like this: |
| 15 | * mov ip, sp |
| 16 | * stmdb sp!, {fp, ip, lr, pc} |
| 17 | * sub fp, ip, #4 |
| 18 | * |
| 19 | * A simple function epilogue looks like this: |
| 20 | * ldm sp, {fp, sp, pc} |
| 21 | * |
| 22 | * Note that with framepointer enabled, even the leaf functions have the same |
| 23 | * prologue and epilogue, therefore we can ignore the LR value in this case. |
| 24 | */ |
Uwe Kleine-König | 4bf1fa5 | 2009-07-21 09:56:27 +0100 | [diff] [blame] | 25 | int notrace unwind_frame(struct stackframe *frame) |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 26 | { |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 27 | unsigned long high, low; |
| 28 | unsigned long fp = frame->fp; |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 29 | |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 30 | /* only go to a higher address on the stack */ |
| 31 | low = frame->sp; |
Will Deacon | d33aadb | 2010-11-04 18:22:51 +0100 | [diff] [blame] | 32 | high = ALIGN(low, THREAD_SIZE); |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 33 | |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 34 | /* check current frame pointer is within bounds */ |
Konstantin Khlebnikov | 3abb667 | 2013-12-05 14:23:48 +0100 | [diff] [blame] | 35 | if (fp < low + 12 || fp > high - 4) |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 36 | return -EINVAL; |
| 37 | |
| 38 | /* restore the registers from the stack frame */ |
| 39 | frame->fp = *(unsigned long *)(fp - 12); |
| 40 | frame->sp = *(unsigned long *)(fp - 8); |
| 41 | frame->pc = *(unsigned long *)(fp - 4); |
| 42 | |
| 43 | return 0; |
| 44 | } |
| 45 | #endif |
| 46 | |
Uwe Kleine-König | 4bf1fa5 | 2009-07-21 09:56:27 +0100 | [diff] [blame] | 47 | void notrace walk_stackframe(struct stackframe *frame, |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 48 | int (*fn)(struct stackframe *, void *), void *data) |
| 49 | { |
| 50 | while (1) { |
| 51 | int ret; |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 52 | |
| 53 | if (fn(frame, data)) |
| 54 | break; |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 55 | ret = unwind_frame(frame); |
| 56 | if (ret < 0) |
| 57 | break; |
| 58 | } |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 59 | } |
Al Viro | 7b104bc | 2007-05-15 20:37:20 +0100 | [diff] [blame] | 60 | EXPORT_SYMBOL(walk_stackframe); |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 61 | |
| 62 | #ifdef CONFIG_STACKTRACE |
| 63 | struct stack_trace_data { |
| 64 | struct stack_trace *trace; |
Russell King | 07b4034 | 2014-05-03 16:17:16 +0100 | [diff] [blame] | 65 | unsigned long last_pc; |
Nicolas Pitre | f76e915 | 2008-04-24 01:31:46 -0400 | [diff] [blame] | 66 | unsigned int no_sched_functions; |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 67 | unsigned int skip; |
| 68 | }; |
| 69 | |
| 70 | static int save_trace(struct stackframe *frame, void *d) |
| 71 | { |
| 72 | struct stack_trace_data *data = d; |
| 73 | struct stack_trace *trace = data->trace; |
Russell King | 07b4034 | 2014-05-03 16:17:16 +0100 | [diff] [blame] | 74 | struct pt_regs *regs; |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 75 | unsigned long addr = frame->pc; |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 76 | |
Nicolas Pitre | f76e915 | 2008-04-24 01:31:46 -0400 | [diff] [blame] | 77 | if (data->no_sched_functions && in_sched_functions(addr)) |
| 78 | return 0; |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 79 | if (data->skip) { |
| 80 | data->skip--; |
| 81 | return 0; |
| 82 | } |
| 83 | |
Nicolas Pitre | f76e915 | 2008-04-24 01:31:46 -0400 | [diff] [blame] | 84 | trace->entries[trace->nr_entries++] = addr; |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 85 | |
Russell King | 07b4034 | 2014-05-03 16:17:16 +0100 | [diff] [blame] | 86 | if (trace->nr_entries >= trace->max_entries) |
| 87 | return 1; |
| 88 | |
| 89 | /* |
| 90 | * in_exception_text() is designed to test if the PC is one of |
| 91 | * the functions which has an exception stack above it, but |
| 92 | * unfortunately what is in frame->pc is the return LR value, |
| 93 | * not the saved PC value. So, we need to track the previous |
| 94 | * frame PC value when doing this. |
| 95 | */ |
| 96 | addr = data->last_pc; |
| 97 | data->last_pc = frame->pc; |
| 98 | if (!in_exception_text(addr)) |
| 99 | return 0; |
| 100 | |
| 101 | regs = (struct pt_regs *)frame->sp; |
| 102 | |
| 103 | trace->entries[trace->nr_entries++] = regs->ARM_pc; |
| 104 | |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 105 | return trace->nr_entries >= trace->max_entries; |
| 106 | } |
| 107 | |
Russell King | 3683f44 | 2014-05-03 11:03:28 +0100 | [diff] [blame] | 108 | /* This must be noinline to so that our skip calculation works correctly */ |
| 109 | static noinline void __save_stack_trace(struct task_struct *tsk, |
| 110 | struct stack_trace *trace, unsigned int nosched) |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 111 | { |
| 112 | struct stack_trace_data data; |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 113 | struct stackframe frame; |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 114 | |
| 115 | data.trace = trace; |
Russell King | 07b4034 | 2014-05-03 16:17:16 +0100 | [diff] [blame] | 116 | data.last_pc = ULONG_MAX; |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 117 | data.skip = trace->skip; |
Russell King | 3683f44 | 2014-05-03 11:03:28 +0100 | [diff] [blame] | 118 | data.no_sched_functions = nosched; |
Nicolas Pitre | f76e915 | 2008-04-24 01:31:46 -0400 | [diff] [blame] | 119 | |
| 120 | if (tsk != current) { |
| 121 | #ifdef CONFIG_SMP |
| 122 | /* |
Russell King | d5996b2 | 2011-01-15 09:27:04 +0000 | [diff] [blame] | 123 | * What guarantees do we have here that 'tsk' is not |
| 124 | * running on another CPU? For now, ignore it as we |
| 125 | * can't guarantee we won't explode. |
Nicolas Pitre | f76e915 | 2008-04-24 01:31:46 -0400 | [diff] [blame] | 126 | */ |
Russell King | d5996b2 | 2011-01-15 09:27:04 +0000 | [diff] [blame] | 127 | if (trace->nr_entries < trace->max_entries) |
| 128 | trace->entries[trace->nr_entries++] = ULONG_MAX; |
| 129 | return; |
Nicolas Pitre | f76e915 | 2008-04-24 01:31:46 -0400 | [diff] [blame] | 130 | #else |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 131 | frame.fp = thread_saved_fp(tsk); |
| 132 | frame.sp = thread_saved_sp(tsk); |
| 133 | frame.lr = 0; /* recovered from the stack */ |
| 134 | frame.pc = thread_saved_pc(tsk); |
Nicolas Pitre | f76e915 | 2008-04-24 01:31:46 -0400 | [diff] [blame] | 135 | #endif |
| 136 | } else { |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 137 | register unsigned long current_sp asm ("sp"); |
| 138 | |
Russell King | 3683f44 | 2014-05-03 11:03:28 +0100 | [diff] [blame] | 139 | /* We don't want this function nor the caller */ |
| 140 | data.skip += 2; |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 141 | frame.fp = (unsigned long)__builtin_frame_address(0); |
| 142 | frame.sp = current_sp; |
| 143 | frame.lr = (unsigned long)__builtin_return_address(0); |
Russell King | 3683f44 | 2014-05-03 11:03:28 +0100 | [diff] [blame] | 144 | frame.pc = (unsigned long)__save_stack_trace; |
Nicolas Pitre | f76e915 | 2008-04-24 01:31:46 -0400 | [diff] [blame] | 145 | } |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 146 | |
Catalin Marinas | 2d7c11b | 2009-02-11 13:07:53 +0100 | [diff] [blame] | 147 | walk_stackframe(&frame, save_trace, &data); |
Nicolas Pitre | f76e915 | 2008-04-24 01:31:46 -0400 | [diff] [blame] | 148 | if (trace->nr_entries < trace->max_entries) |
| 149 | trace->entries[trace->nr_entries++] = ULONG_MAX; |
| 150 | } |
| 151 | |
Lin Yongting | 9c98666 | 2014-05-04 16:27:41 +0100 | [diff] [blame] | 152 | void save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace) |
| 153 | { |
| 154 | struct stack_trace_data data; |
| 155 | struct stackframe frame; |
| 156 | |
| 157 | data.trace = trace; |
| 158 | data.skip = trace->skip; |
| 159 | data.no_sched_functions = 0; |
| 160 | |
| 161 | frame.fp = regs->ARM_fp; |
| 162 | frame.sp = regs->ARM_sp; |
| 163 | frame.lr = regs->ARM_lr; |
| 164 | frame.pc = regs->ARM_pc; |
| 165 | |
| 166 | walk_stackframe(&frame, save_trace, &data); |
| 167 | if (trace->nr_entries < trace->max_entries) |
| 168 | trace->entries[trace->nr_entries++] = ULONG_MAX; |
| 169 | } |
| 170 | |
Russell King | 3683f44 | 2014-05-03 11:03:28 +0100 | [diff] [blame] | 171 | void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace) |
| 172 | { |
| 173 | __save_stack_trace(tsk, trace, 1); |
| 174 | } |
| 175 | |
Nicolas Pitre | f76e915 | 2008-04-24 01:31:46 -0400 | [diff] [blame] | 176 | void save_stack_trace(struct stack_trace *trace) |
| 177 | { |
Russell King | 3683f44 | 2014-05-03 11:03:28 +0100 | [diff] [blame] | 178 | __save_stack_trace(current, trace, 0); |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 179 | } |
Ingo Molnar | 7b4c950 | 2008-07-03 09:17:55 +0200 | [diff] [blame] | 180 | EXPORT_SYMBOL_GPL(save_stack_trace); |
Russell King | f16fb1e | 2007-04-28 09:59:37 +0100 | [diff] [blame] | 181 | #endif |