1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2022 Loongson Technology Corporation Limited
4  */
5 #include <linux/cpumask.h>
6 #include <linux/ftrace.h>
7 #include <linux/kallsyms.h>
8 
9 #include <asm/inst.h>
10 #include <asm/loongson.h>
11 #include <asm/ptrace.h>
12 #include <asm/setup.h>
13 #include <asm/unwind.h>
14 
15 extern const int unwind_hint_ade;
16 extern const int unwind_hint_ale;
17 extern const int unwind_hint_bp;
18 extern const int unwind_hint_fpe;
19 extern const int unwind_hint_fpu;
20 extern const int unwind_hint_lsx;
21 extern const int unwind_hint_lasx;
22 extern const int unwind_hint_lbt;
23 extern const int unwind_hint_ri;
24 extern const int unwind_hint_watch;
25 extern unsigned long eentry;
26 #ifdef CONFIG_NUMA
27 extern unsigned long pcpu_handlers[NR_CPUS];
28 #endif
29 
scan_handlers(unsigned long entry_offset)30 static inline bool scan_handlers(unsigned long entry_offset)
31 {
32 	int idx, offset;
33 
34 	if (entry_offset >= EXCCODE_INT_START * VECSIZE)
35 		return false;
36 
37 	idx = entry_offset / VECSIZE;
38 	offset = entry_offset % VECSIZE;
39 	switch (idx) {
40 	case EXCCODE_ADE:
41 		return offset == unwind_hint_ade;
42 	case EXCCODE_ALE:
43 		return offset == unwind_hint_ale;
44 	case EXCCODE_BP:
45 		return offset == unwind_hint_bp;
46 	case EXCCODE_FPE:
47 		return offset == unwind_hint_fpe;
48 	case EXCCODE_FPDIS:
49 		return offset == unwind_hint_fpu;
50 	case EXCCODE_LSXDIS:
51 		return offset == unwind_hint_lsx;
52 	case EXCCODE_LASXDIS:
53 		return offset == unwind_hint_lasx;
54 	case EXCCODE_BTDIS:
55 		return offset == unwind_hint_lbt;
56 	case EXCCODE_INE:
57 		return offset == unwind_hint_ri;
58 	case EXCCODE_WATCH:
59 		return offset == unwind_hint_watch;
60 	default:
61 		return false;
62 	}
63 }
64 
fix_exception(unsigned long pc)65 static inline bool fix_exception(unsigned long pc)
66 {
67 #ifdef CONFIG_NUMA
68 	int cpu;
69 
70 	for_each_possible_cpu(cpu) {
71 		if (!pcpu_handlers[cpu])
72 			continue;
73 		if (scan_handlers(pc - pcpu_handlers[cpu]))
74 			return true;
75 	}
76 #endif
77 	return scan_handlers(pc - eentry);
78 }
79 
80 /*
81  * As we meet ftrace_regs_entry, reset first flag like first doing
82  * tracing. Prologue analysis will stop soon because PC is at entry.
83  */
fix_ftrace(unsigned long pc)84 static inline bool fix_ftrace(unsigned long pc)
85 {
86 #ifdef CONFIG_DYNAMIC_FTRACE
87 	return pc == (unsigned long)ftrace_call + LOONGARCH_INSN_SIZE;
88 #else
89 	return false;
90 #endif
91 }
92 
unwind_state_fixup(struct unwind_state * state)93 static inline bool unwind_state_fixup(struct unwind_state *state)
94 {
95 	if (!fix_exception(state->pc) && !fix_ftrace(state->pc))
96 		return false;
97 
98 	state->reset = true;
99 	return true;
100 }
101 
102 /*
103  * LoongArch function prologue is like follows,
104  *     [instructions not use stack var]
105  *     addi.d sp, sp, -imm
106  *     st.d   xx, sp, offset <- save callee saved regs and
107  *     st.d   yy, sp, offset    save ra if function is nest.
108  *     [others instructions]
109  */
unwind_by_prologue(struct unwind_state * state)110 static bool unwind_by_prologue(struct unwind_state *state)
111 {
112 	long frame_ra = -1;
113 	unsigned long frame_size = 0;
114 	unsigned long size, offset, pc;
115 	struct pt_regs *regs;
116 	struct stack_info *info = &state->stack_info;
117 	union loongarch_instruction *ip, *ip_end;
118 
119 	if (state->sp >= info->end || state->sp < info->begin)
120 		return false;
121 
122 	if (state->reset) {
123 		regs = (struct pt_regs *)state->sp;
124 		state->first = true;
125 		state->reset = false;
126 		state->pc = regs->csr_era;
127 		state->ra = regs->regs[1];
128 		state->sp = regs->regs[3];
129 		return true;
130 	}
131 
132 	/*
133 	 * When first is not set, the PC is a return address in the previous frame.
134 	 * We need to adjust its value in case overflow to the next symbol.
135 	 */
136 	pc = state->pc - (state->first ? 0 : LOONGARCH_INSN_SIZE);
137 	if (!kallsyms_lookup_size_offset(pc, &size, &offset))
138 		return false;
139 
140 	ip = (union loongarch_instruction *)(pc - offset);
141 	ip_end = (union loongarch_instruction *)pc;
142 
143 	while (ip < ip_end) {
144 		if (is_stack_alloc_ins(ip)) {
145 			frame_size = (1 << 12) - ip->reg2i12_format.immediate;
146 			ip++;
147 			break;
148 		}
149 		ip++;
150 	}
151 
152 	/*
153 	 * Can't find stack alloc action, PC may be in a leaf function. Only the
154 	 * first being true is reasonable, otherwise indicate analysis is broken.
155 	 */
156 	if (!frame_size) {
157 		if (state->first)
158 			goto first;
159 
160 		return false;
161 	}
162 
163 	while (ip < ip_end) {
164 		if (is_ra_save_ins(ip)) {
165 			frame_ra = ip->reg2i12_format.immediate;
166 			break;
167 		}
168 		if (is_branch_ins(ip))
169 			break;
170 		ip++;
171 	}
172 
173 	/* Can't find save $ra action, PC may be in a leaf function, too. */
174 	if (frame_ra < 0) {
175 		if (state->first) {
176 			state->sp = state->sp + frame_size;
177 			goto first;
178 		}
179 		return false;
180 	}
181 
182 	state->pc = *(unsigned long *)(state->sp + frame_ra);
183 	state->sp = state->sp + frame_size;
184 	goto out;
185 
186 first:
187 	state->pc = state->ra;
188 
189 out:
190 	state->first = false;
191 	return unwind_state_fixup(state) || __kernel_text_address(state->pc);
192 }
193 
next_frame(struct unwind_state * state)194 static bool next_frame(struct unwind_state *state)
195 {
196 	unsigned long pc;
197 	struct pt_regs *regs;
198 	struct stack_info *info = &state->stack_info;
199 
200 	if (unwind_done(state))
201 		return false;
202 
203 	do {
204 		if (unwind_by_prologue(state)) {
205 			state->pc = unwind_graph_addr(state, state->pc, state->sp);
206 			return true;
207 		}
208 
209 		if (info->type == STACK_TYPE_IRQ && info->end == state->sp) {
210 			regs = (struct pt_regs *)info->next_sp;
211 			pc = regs->csr_era;
212 
213 			if (user_mode(regs) || !__kernel_text_address(pc))
214 				goto out;
215 
216 			state->first = true;
217 			state->pc = pc;
218 			state->ra = regs->regs[1];
219 			state->sp = regs->regs[3];
220 			get_stack_info(state->sp, state->task, info);
221 
222 			return true;
223 		}
224 
225 		state->sp = info->next_sp;
226 
227 	} while (!get_stack_info(state->sp, state->task, info));
228 
229 out:
230 	state->stack_info.type = STACK_TYPE_UNKNOWN;
231 	return false;
232 }
233 
unwind_get_return_address(struct unwind_state * state)234 unsigned long unwind_get_return_address(struct unwind_state *state)
235 {
236 	return __unwind_get_return_address(state);
237 }
238 EXPORT_SYMBOL_GPL(unwind_get_return_address);
239 
unwind_start(struct unwind_state * state,struct task_struct * task,struct pt_regs * regs)240 void unwind_start(struct unwind_state *state, struct task_struct *task,
241 		    struct pt_regs *regs)
242 {
243 	__unwind_start(state, task, regs);
244 	state->type = UNWINDER_PROLOGUE;
245 	state->first = true;
246 
247 	/*
248 	 * The current PC is not kernel text address, we cannot find its
249 	 * relative symbol. Thus, prologue analysis will be broken. Luckily,
250 	 * we can use the default_next_frame().
251 	 */
252 	if (!__kernel_text_address(state->pc)) {
253 		state->type = UNWINDER_GUESS;
254 		if (!unwind_done(state))
255 			unwind_next_frame(state);
256 	}
257 }
258 EXPORT_SYMBOL_GPL(unwind_start);
259 
unwind_next_frame(struct unwind_state * state)260 bool unwind_next_frame(struct unwind_state *state)
261 {
262 	return state->type == UNWINDER_PROLOGUE ?
263 			next_frame(state) : default_next_frame(state);
264 }
265 EXPORT_SYMBOL_GPL(unwind_next_frame);
266