Commit | Line | Data |
---|---|---|
5f307491 DK |
1 | #include <linux/oprofile.h> |
2 | #include <linux/sched.h> | |
3 | #include <linux/mm.h> | |
4 | #include <linux/uaccess.h> | |
5 | #include <asm/ptrace.h> | |
6 | #include <asm/stacktrace.h> | |
7 | #include <linux/stacktrace.h> | |
8 | #include <linux/kernel.h> | |
9 | #include <asm/sections.h> | |
10 | #include <asm/inst.h> | |
11 | ||
12 | struct stackframe { | |
13 | unsigned long sp; | |
14 | unsigned long pc; | |
15 | unsigned long ra; | |
16 | }; | |
17 | ||
18 | static inline int get_mem(unsigned long addr, unsigned long *result) | |
19 | { | |
20 | unsigned long *address = (unsigned long *) addr; | |
21 | if (!access_ok(VERIFY_READ, addr, sizeof(unsigned long))) | |
22 | return -1; | |
23 | if (__copy_from_user_inatomic(result, address, sizeof(unsigned long))) | |
24 | return -3; | |
25 | return 0; | |
26 | } | |
27 | ||
28 | /* | |
29 | * These two instruction helpers were taken from process.c | |
30 | */ | |
31 | static inline int is_ra_save_ins(union mips_instruction *ip) | |
32 | { | |
33 | /* sw / sd $ra, offset($sp) */ | |
34 | return (ip->i_format.opcode == sw_op || ip->i_format.opcode == sd_op) | |
35 | && ip->i_format.rs == 29 && ip->i_format.rt == 31; | |
36 | } | |
37 | ||
38 | static inline int is_sp_move_ins(union mips_instruction *ip) | |
39 | { | |
40 | /* addiu/daddiu sp,sp,-imm */ | |
41 | if (ip->i_format.rs != 29 || ip->i_format.rt != 29) | |
42 | return 0; | |
43 | if (ip->i_format.opcode == addiu_op || ip->i_format.opcode == daddiu_op) | |
44 | return 1; | |
45 | return 0; | |
46 | } | |
47 | ||
48 | /* | |
49 | * Looks for specific instructions that mark the end of a function. | |
50 | * This usually means we ran into the code area of the previous function. | |
51 | */ | |
52 | static inline int is_end_of_function_marker(union mips_instruction *ip) | |
53 | { | |
54 | /* jr ra */ | |
55 | if (ip->r_format.func == jr_op && ip->r_format.rs == 31) | |
56 | return 1; | |
57 | /* lui gp */ | |
58 | if (ip->i_format.opcode == lui_op && ip->i_format.rt == 28) | |
59 | return 1; | |
60 | return 0; | |
61 | } | |
62 | ||
63 | /* | |
64 | * TODO for userspace stack unwinding: | |
65 | * - handle cases where the stack is adjusted inside a function | |
66 | * (generally doesn't happen) | |
67 | * - find optimal value for max_instr_check | |
569309b4 | 68 | * - try to find a better way to handle leaf functions |
5f307491 DK |
69 | */ |
70 | ||
71 | static inline int unwind_user_frame(struct stackframe *old_frame, | |
72 | const unsigned int max_instr_check) | |
73 | { | |
74 | struct stackframe new_frame = *old_frame; | |
75 | off_t ra_offset = 0; | |
76 | size_t stack_size = 0; | |
77 | unsigned long addr; | |
78 | ||
79 | if (old_frame->pc == 0 || old_frame->sp == 0 || old_frame->ra == 0) | |
80 | return -9; | |
81 | ||
82 | for (addr = new_frame.pc; (addr + max_instr_check > new_frame.pc) | |
83 | && (!ra_offset || !stack_size); --addr) { | |
84 | union mips_instruction ip; | |
85 | ||
86 | if (get_mem(addr, (unsigned long *) &ip)) | |
87 | return -11; | |
88 | ||
89 | if (is_sp_move_ins(&ip)) { | |
90 | int stack_adjustment = ip.i_format.simmediate; | |
91 | if (stack_adjustment > 0) | |
92 | /* This marks the end of the previous function, | |
93 | which means we overran. */ | |
94 | break; | |
bbaf113a | 95 | stack_size = (unsigned long) stack_adjustment; |
5f307491 DK |
96 | } else if (is_ra_save_ins(&ip)) { |
97 | int ra_slot = ip.i_format.simmediate; | |
98 | if (ra_slot < 0) | |
99 | /* This shouldn't happen. */ | |
100 | break; | |
101 | ra_offset = ra_slot; | |
102 | } else if (is_end_of_function_marker(&ip)) | |
103 | break; | |
104 | } | |
105 | ||
106 | if (!ra_offset || !stack_size) | |
569309b4 | 107 | goto done; |
5f307491 DK |
108 | |
109 | if (ra_offset) { | |
110 | new_frame.ra = old_frame->sp + ra_offset; | |
111 | if (get_mem(new_frame.ra, &(new_frame.ra))) | |
112 | return -13; | |
113 | } | |
114 | ||
115 | if (stack_size) { | |
116 | new_frame.sp = old_frame->sp + stack_size; | |
117 | if (get_mem(new_frame.sp, &(new_frame.sp))) | |
118 | return -14; | |
119 | } | |
120 | ||
121 | if (new_frame.sp > old_frame->sp) | |
122 | return -2; | |
123 | ||
569309b4 | 124 | done: |
5f307491 DK |
125 | new_frame.pc = old_frame->ra; |
126 | *old_frame = new_frame; | |
127 | ||
128 | return 0; | |
129 | } | |
130 | ||
131 | static inline void do_user_backtrace(unsigned long low_addr, | |
132 | struct stackframe *frame, | |
133 | unsigned int depth) | |
134 | { | |
135 | const unsigned int max_instr_check = 512; | |
136 | const unsigned long high_addr = low_addr + THREAD_SIZE; | |
137 | ||
138 | while (depth-- && !unwind_user_frame(frame, max_instr_check)) { | |
139 | oprofile_add_trace(frame->ra); | |
140 | if (frame->sp < low_addr || frame->sp > high_addr) | |
141 | break; | |
142 | } | |
143 | } | |
144 | ||
145 | #ifndef CONFIG_KALLSYMS | |
146 | static inline void do_kernel_backtrace(unsigned long low_addr, | |
147 | struct stackframe *frame, | |
148 | unsigned int depth) { } | |
149 | #else | |
150 | static inline void do_kernel_backtrace(unsigned long low_addr, | |
151 | struct stackframe *frame, | |
152 | unsigned int depth) | |
153 | { | |
154 | while (depth-- && frame->pc) { | |
155 | frame->pc = unwind_stack_by_address(low_addr, | |
156 | &(frame->sp), | |
157 | frame->pc, | |
158 | &(frame->ra)); | |
159 | oprofile_add_trace(frame->ra); | |
160 | } | |
161 | } | |
162 | #endif | |
163 | ||
164 | void notrace op_mips_backtrace(struct pt_regs *const regs, unsigned int depth) | |
165 | { | |
166 | struct stackframe frame = { .sp = regs->regs[29], | |
167 | .pc = regs->cp0_epc, | |
168 | .ra = regs->regs[31] }; | |
169 | const int userspace = user_mode(regs); | |
170 | const unsigned long low_addr = ALIGN(frame.sp, THREAD_SIZE); | |
171 | ||
172 | if (userspace) | |
173 | do_user_backtrace(low_addr, &frame, depth); | |
174 | else | |
175 | do_kernel_backtrace(low_addr, &frame, depth); | |
176 | } |