Commit | Line | Data |
---|---|---|
ecea4ab6 | 1 | #include <linux/export.h> |
f16fb1ec RK |
2 | #include <linux/sched.h> |
3 | #include <linux/stacktrace.h> | |
4 | ||
2d7c11bf | 5 | #include <asm/stacktrace.h> |
07b40341 | 6 | #include <asm/traps.h> |
2d7c11bf CM |
7 | |
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 | */ | |
4bf1fa5a | 25 | int notrace unwind_frame(struct stackframe *frame) |
f16fb1ec | 26 | { |
2d7c11bf CM |
27 | unsigned long high, low; |
28 | unsigned long fp = frame->fp; | |
f16fb1ec | 29 | |
2d7c11bf CM |
30 | /* only go to a higher address on the stack */ |
31 | low = frame->sp; | |
d33aadbf | 32 | high = ALIGN(low, THREAD_SIZE); |
f16fb1ec | 33 | |
2d7c11bf | 34 | /* check current frame pointer is within bounds */ |
3abb6671 | 35 | if (fp < low + 12 || fp > high - 4) |
2d7c11bf | 36 | return -EINVAL; |
f16fb1ec | 37 | |
2d7c11bf CM |
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); | |
f16fb1ec RK |
42 | |
43 | return 0; | |
44 | } | |
2d7c11bf CM |
45 | #endif |
46 | ||
4bf1fa5a | 47 | void notrace walk_stackframe(struct stackframe *frame, |
2d7c11bf CM |
48 | int (*fn)(struct stackframe *, void *), void *data) |
49 | { | |
50 | while (1) { | |
51 | int ret; | |
52 | ||
53 | if (fn(frame, data)) | |
54 | break; | |
55 | ret = unwind_frame(frame); | |
56 | if (ret < 0) | |
57 | break; | |
58 | } | |
59 | } | |
7b104bcb | 60 | EXPORT_SYMBOL(walk_stackframe); |
f16fb1ec RK |
61 | |
62 | #ifdef CONFIG_STACKTRACE | |
63 | struct stack_trace_data { | |
64 | struct stack_trace *trace; | |
07b40341 | 65 | unsigned long last_pc; |
f76e9154 | 66 | unsigned int no_sched_functions; |
f16fb1ec RK |
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; | |
07b40341 | 74 | struct pt_regs *regs; |
2d7c11bf | 75 | unsigned long addr = frame->pc; |
f16fb1ec | 76 | |
f76e9154 NP |
77 | if (data->no_sched_functions && in_sched_functions(addr)) |
78 | return 0; | |
f16fb1ec RK |
79 | if (data->skip) { |
80 | data->skip--; | |
81 | return 0; | |
82 | } | |
83 | ||
f76e9154 | 84 | trace->entries[trace->nr_entries++] = addr; |
f16fb1ec | 85 | |
07b40341 RK |
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 | ||
f16fb1ec RK |
105 | return trace->nr_entries >= trace->max_entries; |
106 | } | |
107 | ||
3683f44c RK |
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) | |
f16fb1ec RK |
111 | { |
112 | struct stack_trace_data data; | |
2d7c11bf | 113 | struct stackframe frame; |
f16fb1ec RK |
114 | |
115 | data.trace = trace; | |
07b40341 | 116 | data.last_pc = ULONG_MAX; |
f16fb1ec | 117 | data.skip = trace->skip; |
3683f44c | 118 | data.no_sched_functions = nosched; |
f76e9154 NP |
119 | |
120 | if (tsk != current) { | |
121 | #ifdef CONFIG_SMP | |
122 | /* | |
d5996b2f RK |
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. | |
f76e9154 | 126 | */ |
d5996b2f RK |
127 | if (trace->nr_entries < trace->max_entries) |
128 | trace->entries[trace->nr_entries++] = ULONG_MAX; | |
129 | return; | |
f76e9154 | 130 | #else |
2d7c11bf CM |
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); | |
f76e9154 NP |
135 | #endif |
136 | } else { | |
3683f44c RK |
137 | /* We don't want this function nor the caller */ |
138 | data.skip += 2; | |
2d7c11bf | 139 | frame.fp = (unsigned long)__builtin_frame_address(0); |
74dbeee0 | 140 | frame.sp = current_stack_pointer; |
2d7c11bf | 141 | frame.lr = (unsigned long)__builtin_return_address(0); |
3683f44c | 142 | frame.pc = (unsigned long)__save_stack_trace; |
f76e9154 | 143 | } |
f16fb1ec | 144 | |
2d7c11bf | 145 | walk_stackframe(&frame, save_trace, &data); |
f76e9154 NP |
146 | if (trace->nr_entries < trace->max_entries) |
147 | trace->entries[trace->nr_entries++] = ULONG_MAX; | |
148 | } | |
149 | ||
9c986661 LY |
150 | void save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace) |
151 | { | |
152 | struct stack_trace_data data; | |
153 | struct stackframe frame; | |
154 | ||
155 | data.trace = trace; | |
156 | data.skip = trace->skip; | |
157 | data.no_sched_functions = 0; | |
158 | ||
159 | frame.fp = regs->ARM_fp; | |
160 | frame.sp = regs->ARM_sp; | |
161 | frame.lr = regs->ARM_lr; | |
162 | frame.pc = regs->ARM_pc; | |
163 | ||
164 | walk_stackframe(&frame, save_trace, &data); | |
165 | if (trace->nr_entries < trace->max_entries) | |
166 | trace->entries[trace->nr_entries++] = ULONG_MAX; | |
167 | } | |
168 | ||
3683f44c RK |
169 | void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace) |
170 | { | |
171 | __save_stack_trace(tsk, trace, 1); | |
172 | } | |
173 | ||
f76e9154 NP |
174 | void save_stack_trace(struct stack_trace *trace) |
175 | { | |
3683f44c | 176 | __save_stack_trace(current, trace, 0); |
f16fb1ec | 177 | } |
7b4c9505 | 178 | EXPORT_SYMBOL_GPL(save_stack_trace); |
f16fb1ec | 179 | #endif |