Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Kernel unwinding support
4 *
5 * (c) 2002-2004 Randolph Chung <tausq@debian.org>
6 *
7 * Derived partially from the IA64 implementation. The PA-RISC
8 * Runtime Architecture Document is also a useful reference to
9 * understand what is happening here
10 */
11
12#include <linux/kernel.h>
13#include <linux/init.h>
14#include <linux/sched.h>
15#include <linux/slab.h>
16#include <linux/sort.h>
17
18#include <linux/uaccess.h>
19#include <asm/assembly.h>
20#include <asm/asm-offsets.h>
21#include <asm/ptrace.h>
22
23#include <asm/unwind.h>
24
25/* #define DEBUG 1 */
26#ifdef DEBUG
27#define dbg(x...) pr_debug(x)
28#else
29#define dbg(x...)
30#endif
31
32#define KERNEL_START (KERNEL_BINARY_TEXT_START)
33
34extern struct unwind_table_entry __start___unwind[];
35extern struct unwind_table_entry __stop___unwind[];
36
37static DEFINE_SPINLOCK(unwind_lock);
38/*
39 * the kernel unwind block is not dynamically allocated so that
40 * we can call unwind_init as early in the bootup process as
41 * possible (before the slab allocator is initialized)
42 */
43static struct unwind_table kernel_unwind_table __ro_after_init;
44static LIST_HEAD(unwind_tables);
45
46static inline const struct unwind_table_entry *
47find_unwind_entry_in_table(const struct unwind_table *table, unsigned long addr)
48{
49 const struct unwind_table_entry *e = NULL;
50 unsigned long lo, hi, mid;
51
52 lo = 0;
53 hi = table->length - 1;
54
55 while (lo <= hi) {
56 mid = (hi - lo) / 2 + lo;
57 e = &table->table[mid];
58 if (addr < e->region_start)
59 hi = mid - 1;
60 else if (addr > e->region_end)
61 lo = mid + 1;
62 else
63 return e;
64 }
65
66 return NULL;
67}
68
69static const struct unwind_table_entry *
70find_unwind_entry(unsigned long addr)
71{
72 struct unwind_table *table;
73 const struct unwind_table_entry *e = NULL;
74
75 if (addr >= kernel_unwind_table.start &&
76 addr <= kernel_unwind_table.end)
77 e = find_unwind_entry_in_table(&kernel_unwind_table, addr);
78 else {
79 unsigned long flags;
80
81 spin_lock_irqsave(&unwind_lock, flags);
82 list_for_each_entry(table, &unwind_tables, list) {
83 if (addr >= table->start &&
84 addr <= table->end)
85 e = find_unwind_entry_in_table(table, addr);
86 if (e) {
87 /* Move-to-front to exploit common traces */
88 list_move(&table->list, &unwind_tables);
89 break;
90 }
91 }
92 spin_unlock_irqrestore(&unwind_lock, flags);
93 }
94
95 return e;
96}
97
98static void
99unwind_table_init(struct unwind_table *table, const char *name,
100 unsigned long base_addr, unsigned long gp,
101 void *table_start, void *table_end)
102{
103 struct unwind_table_entry *start = table_start;
104 struct unwind_table_entry *end =
105 (struct unwind_table_entry *)table_end - 1;
106
107 table->name = name;
108 table->base_addr = base_addr;
109 table->gp = gp;
110 table->start = base_addr + start->region_start;
111 table->end = base_addr + end->region_end;
112 table->table = (struct unwind_table_entry *)table_start;
113 table->length = end - start + 1;
114 INIT_LIST_HEAD(&table->list);
115
116 for (; start <= end; start++) {
117 if (start < end &&
118 start->region_end > (start+1)->region_start) {
119 pr_warn("Out of order unwind entry! %px and %px\n",
120 start, start+1);
121 }
122
123 start->region_start += base_addr;
124 start->region_end += base_addr;
125 }
126}
127
128static int cmp_unwind_table_entry(const void *a, const void *b)
129{
130 return ((const struct unwind_table_entry *)a)->region_start
131 - ((const struct unwind_table_entry *)b)->region_start;
132}
133
134static void
135unwind_table_sort(struct unwind_table_entry *start,
136 struct unwind_table_entry *finish)
137{
138 sort(start, finish - start, sizeof(struct unwind_table_entry),
139 cmp_unwind_table_entry, NULL);
140}
141
142struct unwind_table *
143unwind_table_add(const char *name, unsigned long base_addr,
144 unsigned long gp,
145 void *start, void *end)
146{
147 struct unwind_table *table;
148 unsigned long flags;
149 struct unwind_table_entry *s = (struct unwind_table_entry *)start;
150 struct unwind_table_entry *e = (struct unwind_table_entry *)end;
151
152 unwind_table_sort(s, e);
153
154 table = kmalloc(sizeof(struct unwind_table), GFP_USER);
155 if (table == NULL)
156 return NULL;
157 unwind_table_init(table, name, base_addr, gp, start, end);
158 spin_lock_irqsave(&unwind_lock, flags);
159 list_add_tail(&table->list, &unwind_tables);
160 spin_unlock_irqrestore(&unwind_lock, flags);
161
162 return table;
163}
164
165void unwind_table_remove(struct unwind_table *table)
166{
167 unsigned long flags;
168
169 spin_lock_irqsave(&unwind_lock, flags);
170 list_del(&table->list);
171 spin_unlock_irqrestore(&unwind_lock, flags);
172
173 kfree(table);
174}
175
176/* Called from setup_arch to import the kernel unwind info */
177int __init unwind_init(void)
178{
179 long start, stop;
180 register unsigned long gp __asm__ ("r27");
181
182 start = (long)&__start___unwind[0];
183 stop = (long)&__stop___unwind[0];
184
185 dbg("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",
186 start, stop,
187 (stop - start) / sizeof(struct unwind_table_entry));
188
189 unwind_table_init(&kernel_unwind_table, "kernel", KERNEL_START,
190 gp,
191 &__start___unwind[0], &__stop___unwind[0]);
192#if 0
193 {
194 int i;
195 for (i = 0; i < 10; i++)
196 {
197 printk("region 0x%x-0x%x\n",
198 __start___unwind[i].region_start,
199 __start___unwind[i].region_end);
200 }
201 }
202#endif
203 return 0;
204}
205
206static int unwind_special(struct unwind_frame_info *info, unsigned long pc, int frame_size)
207{
208 /*
209 * We have to use void * instead of a function pointer, because
210 * function pointers aren't a pointer to the function on 64-bit.
211 * Make them const so the compiler knows they live in .text
212 * Note: We could use dereference_kernel_function_descriptor()
213 * instead but we want to keep it simple here.
214 */
215 extern void * const handle_interruption;
216 extern void * const ret_from_kernel_thread;
217 extern void * const syscall_exit;
218 extern void * const intr_return;
219 extern void * const _switch_to_ret;
220#ifdef CONFIG_IRQSTACKS
221 extern void * const _call_on_stack;
222#endif /* CONFIG_IRQSTACKS */
223
224 if (pc == (unsigned long) &handle_interruption) {
225 struct pt_regs *regs = (struct pt_regs *)(info->sp - frame_size - PT_SZ_ALGN);
226 dbg("Unwinding through handle_interruption()\n");
227 info->prev_sp = regs->gr[30];
228 info->prev_ip = regs->iaoq[0];
229 return 1;
230 }
231
232 if (pc == (unsigned long) &ret_from_kernel_thread ||
233 pc == (unsigned long) &syscall_exit) {
234 info->prev_sp = info->prev_ip = 0;
235 return 1;
236 }
237
238 if (pc == (unsigned long) &intr_return) {
239 struct pt_regs *regs;
240
241 dbg("Found intr_return()\n");
242 regs = (struct pt_regs *)(info->sp - PT_SZ_ALGN);
243 info->prev_sp = regs->gr[30];
244 info->prev_ip = regs->iaoq[0];
245 info->rp = regs->gr[2];
246 return 1;
247 }
248
249 if (pc == (unsigned long) &_switch_to_ret) {
250 info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
251 info->prev_ip = *(unsigned long *)(info->prev_sp - RP_OFFSET);
252 return 1;
253 }
254
255#ifdef CONFIG_IRQSTACKS
256 if (pc == (unsigned long) &_call_on_stack) {
257 info->prev_sp = *(unsigned long *)(info->sp - FRAME_SIZE - REG_SZ);
258 info->prev_ip = *(unsigned long *)(info->sp - FRAME_SIZE - RP_OFFSET);
259 return 1;
260 }
261#endif
262
263 return 0;
264}
265
266static void unwind_frame_regs(struct unwind_frame_info *info)
267{
268 const struct unwind_table_entry *e;
269 unsigned long npc;
270 unsigned int insn;
271 long frame_size = 0;
272 int looking_for_rp, rpoffset = 0;
273
274 e = find_unwind_entry(info->ip);
275 if (e == NULL) {
276 unsigned long sp;
277
278 dbg("Cannot find unwind entry for %pS; forced unwinding\n",
279 (void *) info->ip);
280
281 /* Since we are doing the unwinding blind, we don't know if
282 we are adjusting the stack correctly or extracting the rp
283 correctly. The rp is checked to see if it belongs to the
284 kernel text section, if not we assume we don't have a
285 correct stack frame and we continue to unwind the stack.
286 This is not quite correct, and will fail for loadable
287 modules. */
288 sp = info->sp & ~63;
289 do {
290 unsigned long tmp;
291
292 info->prev_sp = sp - 64;
293 info->prev_ip = 0;
294
295 /* The stack is at the end inside the thread_union
296 * struct. If we reach data, we have reached the
297 * beginning of the stack and should stop unwinding. */
298 if (info->prev_sp >= (unsigned long) task_thread_info(info->t) &&
299 info->prev_sp < ((unsigned long) task_thread_info(info->t)
300 + THREAD_SZ_ALGN)) {
301 info->prev_sp = 0;
302 break;
303 }
304
305 if (get_user(tmp, (unsigned long *)(info->prev_sp - RP_OFFSET)))
306 break;
307 info->prev_ip = tmp;
308 sp = info->prev_sp;
309 } while (!kernel_text_address(info->prev_ip));
310
311 info->rp = 0;
312
313 dbg("analyzing func @ %lx with no unwind info, setting "
314 "prev_sp=%lx prev_ip=%lx\n", info->ip,
315 info->prev_sp, info->prev_ip);
316 } else {
317 dbg("e->start = 0x%x, e->end = 0x%x, Save_SP = %d, "
318 "Save_RP = %d, Millicode = %d size = %u\n",
319 e->region_start, e->region_end, e->Save_SP, e->Save_RP,
320 e->Millicode, e->Total_frame_size);
321
322 looking_for_rp = e->Save_RP;
323
324 for (npc = e->region_start;
325 (frame_size < (e->Total_frame_size << 3) ||
326 looking_for_rp) &&
327 npc < info->ip;
328 npc += 4) {
329
330 insn = *(unsigned int *)npc;
331
332 if ((insn & 0xffffc001) == 0x37de0000 ||
333 (insn & 0xffe00001) == 0x6fc00000) {
334 /* ldo X(sp), sp, or stwm X,D(sp) */
335 frame_size += (insn & 0x3fff) >> 1;
336 dbg("analyzing func @ %lx, insn=%08x @ "
337 "%lx, frame_size = %ld\n", info->ip,
338 insn, npc, frame_size);
339 } else if ((insn & 0xffe00009) == 0x73c00008) {
340 /* std,ma X,D(sp) */
341 frame_size += ((insn >> 4) & 0x3ff) << 3;
342 dbg("analyzing func @ %lx, insn=%08x @ "
343 "%lx, frame_size = %ld\n", info->ip,
344 insn, npc, frame_size);
345 } else if (insn == 0x6bc23fd9) {
346 /* stw rp,-20(sp) */
347 rpoffset = 20;
348 looking_for_rp = 0;
349 dbg("analyzing func @ %lx, insn=stw rp,"
350 "-20(sp) @ %lx\n", info->ip, npc);
351 } else if (insn == 0x0fc212c1) {
352 /* std rp,-16(sr0,sp) */
353 rpoffset = 16;
354 looking_for_rp = 0;
355 dbg("analyzing func @ %lx, insn=std rp,"
356 "-16(sp) @ %lx\n", info->ip, npc);
357 }
358 }
359
360 if (frame_size > e->Total_frame_size << 3)
361 frame_size = e->Total_frame_size << 3;
362
363 if (!unwind_special(info, e->region_start, frame_size)) {
364 info->prev_sp = info->sp - frame_size;
365 if (e->Millicode)
366 info->rp = info->r31;
367 else if (rpoffset)
368 info->rp = *(unsigned long *)(info->prev_sp - rpoffset);
369 info->prev_ip = info->rp;
370 info->rp = 0;
371 }
372
373 dbg("analyzing func @ %lx, setting prev_sp=%lx "
374 "prev_ip=%lx npc=%lx\n", info->ip, info->prev_sp,
375 info->prev_ip, npc);
376 }
377}
378
379void unwind_frame_init(struct unwind_frame_info *info, struct task_struct *t,
380 struct pt_regs *regs)
381{
382 memset(info, 0, sizeof(struct unwind_frame_info));
383 info->t = t;
384 info->sp = regs->gr[30];
385 info->ip = regs->iaoq[0];
386 info->rp = regs->gr[2];
387 info->r31 = regs->gr[31];
388
389 dbg("(%d) Start unwind from sp=%08lx ip=%08lx\n",
390 t ? (int)t->pid : -1, info->sp, info->ip);
391}
392
393void unwind_frame_init_from_blocked_task(struct unwind_frame_info *info, struct task_struct *t)
394{
395 struct pt_regs *r = &t->thread.regs;
396 struct pt_regs *r2;
397
398 r2 = kmalloc(sizeof(struct pt_regs), GFP_ATOMIC);
399 if (!r2)
400 return;
401 *r2 = *r;
402 r2->gr[30] = r->ksp;
403 r2->iaoq[0] = r->kpc;
404 unwind_frame_init(info, t, r2);
405 kfree(r2);
406}
407
408#define get_parisc_stackpointer() ({ \
409 unsigned long sp; \
410 __asm__("copy %%r30, %0" : "=r"(sp)); \
411 (sp); \
412})
413
414void unwind_frame_init_task(struct unwind_frame_info *info,
415 struct task_struct *task, struct pt_regs *regs)
416{
417 task = task ? task : current;
418
419 if (task == current) {
420 struct pt_regs r;
421
422 if (!regs) {
423 memset(&r, 0, sizeof(r));
424 r.iaoq[0] = _THIS_IP_;
425 r.gr[2] = _RET_IP_;
426 r.gr[30] = get_parisc_stackpointer();
427 regs = &r;
428 }
429 unwind_frame_init(info, task, regs);
430 } else {
431 unwind_frame_init_from_blocked_task(info, task);
432 }
433}
434
435int unwind_once(struct unwind_frame_info *next_frame)
436{
437 unwind_frame_regs(next_frame);
438
439 if (next_frame->prev_sp == 0 ||
440 next_frame->prev_ip == 0)
441 return -1;
442
443 next_frame->sp = next_frame->prev_sp;
444 next_frame->ip = next_frame->prev_ip;
445 next_frame->prev_sp = 0;
446 next_frame->prev_ip = 0;
447
448 dbg("(%d) Continue unwind to sp=%08lx ip=%08lx\n",
449 next_frame->t ? (int)next_frame->t->pid : -1,
450 next_frame->sp, next_frame->ip);
451
452 return 0;
453}
454
455int unwind_to_user(struct unwind_frame_info *info)
456{
457 int ret;
458
459 do {
460 ret = unwind_once(info);
461 } while (!ret && !(info->ip & 3));
462
463 return ret;
464}
465
466unsigned long return_address(unsigned int level)
467{
468 struct unwind_frame_info info;
469
470 /* initialize unwind info */
471 unwind_frame_init_task(&info, current, NULL);
472
473 /* unwind stack */
474 level += 2;
475 do {
476 if (unwind_once(&info) < 0 || info.ip == 0)
477 return 0;
478 if (!kernel_text_address(info.ip))
479 return 0;
480 } while (info.ip && level--);
481
482 return info.ip;
483}
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Kernel unwinding support
4 *
5 * (c) 2002-2004 Randolph Chung <tausq@debian.org>
6 *
7 * Derived partially from the IA64 implementation. The PA-RISC
8 * Runtime Architecture Document is also a useful reference to
9 * understand what is happening here
10 */
11
12#include <linux/kernel.h>
13#include <linux/init.h>
14#include <linux/sched.h>
15#include <linux/slab.h>
16#include <linux/sort.h>
17#include <linux/sched/task_stack.h>
18
19#include <linux/uaccess.h>
20#include <asm/assembly.h>
21#include <asm/asm-offsets.h>
22#include <asm/ptrace.h>
23
24#include <asm/unwind.h>
25#include <asm/switch_to.h>
26#include <asm/sections.h>
27
28/* #define DEBUG 1 */
29#ifdef DEBUG
30#define dbg(x...) pr_debug(x)
31#else
32#define dbg(x...)
33#endif
34
35#define KERNEL_START (KERNEL_BINARY_TEXT_START)
36
37extern struct unwind_table_entry __start___unwind[];
38extern struct unwind_table_entry __stop___unwind[];
39
40static DEFINE_SPINLOCK(unwind_lock);
41/*
42 * the kernel unwind block is not dynamically allocated so that
43 * we can call unwind_init as early in the bootup process as
44 * possible (before the slab allocator is initialized)
45 */
46static struct unwind_table kernel_unwind_table __ro_after_init;
47static LIST_HEAD(unwind_tables);
48
49static inline const struct unwind_table_entry *
50find_unwind_entry_in_table(const struct unwind_table *table, unsigned long addr)
51{
52 const struct unwind_table_entry *e = NULL;
53 unsigned long lo, hi, mid;
54
55 lo = 0;
56 hi = table->length - 1;
57
58 while (lo <= hi) {
59 mid = (hi - lo) / 2 + lo;
60 e = &table->table[mid];
61 if (addr < e->region_start)
62 hi = mid - 1;
63 else if (addr > e->region_end)
64 lo = mid + 1;
65 else
66 return e;
67 }
68
69 return NULL;
70}
71
72static const struct unwind_table_entry *
73find_unwind_entry(unsigned long addr)
74{
75 struct unwind_table *table;
76 const struct unwind_table_entry *e = NULL;
77
78 if (addr >= kernel_unwind_table.start &&
79 addr <= kernel_unwind_table.end)
80 e = find_unwind_entry_in_table(&kernel_unwind_table, addr);
81 else {
82 unsigned long flags;
83
84 spin_lock_irqsave(&unwind_lock, flags);
85 list_for_each_entry(table, &unwind_tables, list) {
86 if (addr >= table->start &&
87 addr <= table->end)
88 e = find_unwind_entry_in_table(table, addr);
89 if (e) {
90 /* Move-to-front to exploit common traces */
91 list_move(&table->list, &unwind_tables);
92 break;
93 }
94 }
95 spin_unlock_irqrestore(&unwind_lock, flags);
96 }
97
98 return e;
99}
100
101static void
102unwind_table_init(struct unwind_table *table, const char *name,
103 unsigned long base_addr, unsigned long gp,
104 void *table_start, void *table_end)
105{
106 struct unwind_table_entry *start = table_start;
107 struct unwind_table_entry *end =
108 (struct unwind_table_entry *)table_end - 1;
109
110 table->name = name;
111 table->base_addr = base_addr;
112 table->gp = gp;
113 table->start = base_addr + start->region_start;
114 table->end = base_addr + end->region_end;
115 table->table = (struct unwind_table_entry *)table_start;
116 table->length = end - start + 1;
117 INIT_LIST_HEAD(&table->list);
118
119 for (; start <= end; start++) {
120 if (start < end &&
121 start->region_end > (start+1)->region_start) {
122 pr_warn("Out of order unwind entry! %px and %px\n",
123 start, start+1);
124 }
125
126 start->region_start += base_addr;
127 start->region_end += base_addr;
128 }
129}
130
131static int cmp_unwind_table_entry(const void *a, const void *b)
132{
133 return ((const struct unwind_table_entry *)a)->region_start
134 - ((const struct unwind_table_entry *)b)->region_start;
135}
136
137static void
138unwind_table_sort(struct unwind_table_entry *start,
139 struct unwind_table_entry *finish)
140{
141 sort(start, finish - start, sizeof(struct unwind_table_entry),
142 cmp_unwind_table_entry, NULL);
143}
144
145struct unwind_table *
146unwind_table_add(const char *name, unsigned long base_addr,
147 unsigned long gp,
148 void *start, void *end)
149{
150 struct unwind_table *table;
151 unsigned long flags;
152 struct unwind_table_entry *s = (struct unwind_table_entry *)start;
153 struct unwind_table_entry *e = (struct unwind_table_entry *)end;
154
155 unwind_table_sort(s, e);
156
157 table = kmalloc(sizeof(struct unwind_table), GFP_USER);
158 if (table == NULL)
159 return NULL;
160 unwind_table_init(table, name, base_addr, gp, start, end);
161 spin_lock_irqsave(&unwind_lock, flags);
162 list_add_tail(&table->list, &unwind_tables);
163 spin_unlock_irqrestore(&unwind_lock, flags);
164
165 return table;
166}
167
168void unwind_table_remove(struct unwind_table *table)
169{
170 unsigned long flags;
171
172 spin_lock_irqsave(&unwind_lock, flags);
173 list_del(&table->list);
174 spin_unlock_irqrestore(&unwind_lock, flags);
175
176 kfree(table);
177}
178
179/* Called from setup_arch to import the kernel unwind info */
180int __init unwind_init(void)
181{
182 long start, stop;
183 register unsigned long gp __asm__ ("r27");
184
185 start = (long)&__start___unwind[0];
186 stop = (long)&__stop___unwind[0];
187
188 dbg("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",
189 start, stop,
190 (stop - start) / sizeof(struct unwind_table_entry));
191
192 unwind_table_init(&kernel_unwind_table, "kernel", KERNEL_START,
193 gp,
194 &__start___unwind[0], &__stop___unwind[0]);
195#if 0
196 {
197 int i;
198 for (i = 0; i < 10; i++)
199 {
200 printk("region 0x%x-0x%x\n",
201 __start___unwind[i].region_start,
202 __start___unwind[i].region_end);
203 }
204 }
205#endif
206 return 0;
207}
208
209static bool pc_is_kernel_fn(unsigned long pc, void *fn)
210{
211 return (unsigned long)dereference_kernel_function_descriptor(fn) == pc;
212}
213
214static int unwind_special(struct unwind_frame_info *info, unsigned long pc, int frame_size)
215{
216 /*
217 * We have to use void * instead of a function pointer, because
218 * function pointers aren't a pointer to the function on 64-bit.
219 * Make them const so the compiler knows they live in .text
220 * Note: We could use dereference_kernel_function_descriptor()
221 * instead but we want to keep it simple here.
222 */
223 extern void * const handle_interruption;
224 extern void * const ret_from_kernel_thread;
225 extern void * const syscall_exit;
226 extern void * const intr_return;
227 extern void * const _switch_to_ret;
228#ifdef CONFIG_IRQSTACKS
229 extern void * const _call_on_stack;
230#endif /* CONFIG_IRQSTACKS */
231
232 if (pc_is_kernel_fn(pc, handle_interruption)) {
233 struct pt_regs *regs = (struct pt_regs *)(info->sp - frame_size - PT_SZ_ALGN);
234 dbg("Unwinding through handle_interruption()\n");
235 info->prev_sp = regs->gr[30];
236 info->prev_ip = regs->iaoq[0];
237 return 1;
238 }
239
240 if (pc_is_kernel_fn(pc, ret_from_kernel_thread) ||
241 pc_is_kernel_fn(pc, syscall_exit)) {
242 info->prev_sp = info->prev_ip = 0;
243 return 1;
244 }
245
246 if (pc_is_kernel_fn(pc, intr_return)) {
247 struct pt_regs *regs;
248
249 dbg("Found intr_return()\n");
250 regs = (struct pt_regs *)(info->sp - PT_SZ_ALGN);
251 info->prev_sp = regs->gr[30];
252 info->prev_ip = regs->iaoq[0];
253 info->rp = regs->gr[2];
254 return 1;
255 }
256
257 if (pc_is_kernel_fn(pc, _switch_to) ||
258 pc_is_kernel_fn(pc, _switch_to_ret)) {
259 info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
260 info->prev_ip = *(unsigned long *)(info->prev_sp - RP_OFFSET);
261 return 1;
262 }
263
264#ifdef CONFIG_IRQSTACKS
265 if (pc_is_kernel_fn(pc, _call_on_stack)) {
266 info->prev_sp = *(unsigned long *)(info->sp - FRAME_SIZE - REG_SZ);
267 info->prev_ip = *(unsigned long *)(info->sp - FRAME_SIZE - RP_OFFSET);
268 return 1;
269 }
270#endif
271 return 0;
272}
273
274static void unwind_frame_regs(struct unwind_frame_info *info)
275{
276 const struct unwind_table_entry *e;
277 unsigned long npc;
278 unsigned int insn;
279 long frame_size = 0;
280 int looking_for_rp, rpoffset = 0;
281
282 e = find_unwind_entry(info->ip);
283 if (e == NULL) {
284 unsigned long sp;
285
286 dbg("Cannot find unwind entry for %pS; forced unwinding\n",
287 (void *) info->ip);
288
289 /* Since we are doing the unwinding blind, we don't know if
290 we are adjusting the stack correctly or extracting the rp
291 correctly. The rp is checked to see if it belongs to the
292 kernel text section, if not we assume we don't have a
293 correct stack frame and we continue to unwind the stack.
294 This is not quite correct, and will fail for loadable
295 modules. */
296 sp = info->sp & ~63;
297 do {
298 unsigned long tmp;
299
300 info->prev_sp = sp - 64;
301 info->prev_ip = 0;
302
303 /* Check if stack is inside kernel stack area */
304 if ((info->prev_sp - (unsigned long) task_stack_page(info->t))
305 >= THREAD_SIZE) {
306 info->prev_sp = 0;
307 break;
308 }
309
310 if (copy_from_kernel_nofault(&tmp,
311 (void *)info->prev_sp - RP_OFFSET, sizeof(tmp)))
312 break;
313 info->prev_ip = tmp;
314 sp = info->prev_sp;
315 } while (!kernel_text_address(info->prev_ip));
316
317 info->rp = 0;
318
319 dbg("analyzing func @ %lx with no unwind info, setting "
320 "prev_sp=%lx prev_ip=%lx\n", info->ip,
321 info->prev_sp, info->prev_ip);
322 } else {
323 dbg("e->start = 0x%x, e->end = 0x%x, Save_SP = %d, "
324 "Save_RP = %d, Millicode = %d size = %u\n",
325 e->region_start, e->region_end, e->Save_SP, e->Save_RP,
326 e->Millicode, e->Total_frame_size);
327
328 looking_for_rp = e->Save_RP;
329
330 for (npc = e->region_start;
331 (frame_size < (e->Total_frame_size << 3) ||
332 looking_for_rp) &&
333 npc < info->ip;
334 npc += 4) {
335
336 insn = *(unsigned int *)npc;
337
338 if ((insn & 0xffffc001) == 0x37de0000 ||
339 (insn & 0xffe00001) == 0x6fc00000) {
340 /* ldo X(sp), sp, or stwm X,D(sp) */
341 frame_size += (insn & 0x3fff) >> 1;
342 dbg("analyzing func @ %lx, insn=%08x @ "
343 "%lx, frame_size = %ld\n", info->ip,
344 insn, npc, frame_size);
345 } else if ((insn & 0xffe00009) == 0x73c00008) {
346 /* std,ma X,D(sp) */
347 frame_size += ((insn >> 4) & 0x3ff) << 3;
348 dbg("analyzing func @ %lx, insn=%08x @ "
349 "%lx, frame_size = %ld\n", info->ip,
350 insn, npc, frame_size);
351 } else if (insn == 0x6bc23fd9) {
352 /* stw rp,-20(sp) */
353 rpoffset = 20;
354 looking_for_rp = 0;
355 dbg("analyzing func @ %lx, insn=stw rp,"
356 "-20(sp) @ %lx\n", info->ip, npc);
357 } else if (insn == 0x0fc212c1) {
358 /* std rp,-16(sr0,sp) */
359 rpoffset = 16;
360 looking_for_rp = 0;
361 dbg("analyzing func @ %lx, insn=std rp,"
362 "-16(sp) @ %lx\n", info->ip, npc);
363 }
364 }
365
366 if (frame_size > e->Total_frame_size << 3)
367 frame_size = e->Total_frame_size << 3;
368
369 if (!unwind_special(info, e->region_start, frame_size)) {
370 info->prev_sp = info->sp - frame_size;
371 if (e->Millicode)
372 info->rp = info->r31;
373 else if (rpoffset)
374 info->rp = *(unsigned long *)(info->prev_sp - rpoffset);
375 info->prev_ip = info->rp;
376 info->rp = 0;
377 }
378
379 dbg("analyzing func @ %lx, setting prev_sp=%lx "
380 "prev_ip=%lx npc=%lx\n", info->ip, info->prev_sp,
381 info->prev_ip, npc);
382 }
383}
384
385void unwind_frame_init(struct unwind_frame_info *info, struct task_struct *t,
386 struct pt_regs *regs)
387{
388 memset(info, 0, sizeof(struct unwind_frame_info));
389 info->t = t;
390 info->sp = regs->gr[30];
391 info->ip = regs->iaoq[0];
392 info->rp = regs->gr[2];
393 info->r31 = regs->gr[31];
394
395 dbg("(%d) Start unwind from sp=%08lx ip=%08lx\n",
396 t ? (int)t->pid : -1, info->sp, info->ip);
397}
398
399void unwind_frame_init_from_blocked_task(struct unwind_frame_info *info, struct task_struct *t)
400{
401 struct pt_regs *r = &t->thread.regs;
402 struct pt_regs *r2;
403
404 r2 = kmalloc(sizeof(struct pt_regs), GFP_ATOMIC);
405 if (!r2)
406 return;
407 *r2 = *r;
408 r2->gr[30] = r->ksp;
409 r2->iaoq[0] = r->kpc;
410 unwind_frame_init(info, t, r2);
411 kfree(r2);
412}
413
414#define get_parisc_stackpointer() ({ \
415 unsigned long sp; \
416 __asm__("copy %%r30, %0" : "=r"(sp)); \
417 (sp); \
418})
419
420void unwind_frame_init_task(struct unwind_frame_info *info,
421 struct task_struct *task, struct pt_regs *regs)
422{
423 task = task ? task : current;
424
425 if (task == current) {
426 struct pt_regs r;
427
428 if (!regs) {
429 memset(&r, 0, sizeof(r));
430 r.iaoq[0] = _THIS_IP_;
431 r.gr[2] = _RET_IP_;
432 r.gr[30] = get_parisc_stackpointer();
433 regs = &r;
434 }
435 unwind_frame_init(info, task, regs);
436 } else {
437 unwind_frame_init_from_blocked_task(info, task);
438 }
439}
440
441int unwind_once(struct unwind_frame_info *next_frame)
442{
443 unwind_frame_regs(next_frame);
444
445 if (next_frame->prev_sp == 0 ||
446 next_frame->prev_ip == 0)
447 return -1;
448
449 next_frame->sp = next_frame->prev_sp;
450 next_frame->ip = next_frame->prev_ip;
451 next_frame->prev_sp = 0;
452 next_frame->prev_ip = 0;
453
454 dbg("(%d) Continue unwind to sp=%08lx ip=%08lx\n",
455 next_frame->t ? (int)next_frame->t->pid : -1,
456 next_frame->sp, next_frame->ip);
457
458 return 0;
459}
460
461int unwind_to_user(struct unwind_frame_info *info)
462{
463 int ret;
464
465 do {
466 ret = unwind_once(info);
467 } while (!ret && !(info->ip & 3));
468
469 return ret;
470}
471
472unsigned long return_address(unsigned int level)
473{
474 struct unwind_frame_info info;
475
476 /* initialize unwind info */
477 unwind_frame_init_task(&info, current, NULL);
478
479 /* unwind stack */
480 level += 2;
481 do {
482 if (unwind_once(&info) < 0 || info.ip == 0)
483 return 0;
484 if (!kernel_text_address(info.ip))
485 return 0;
486 } while (info.ip && level--);
487
488 return info.ip;
489}