1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2005-2017 Andes Technology Corporation
3
4 #include <linux/module.h>
5 #include <linux/personality.h>
6 #include <linux/kallsyms.h>
7 #include <linux/hardirq.h>
8 #include <linux/kdebug.h>
9 #include <linux/sched/task_stack.h>
10 #include <linux/uaccess.h>
11 #include <linux/ftrace.h>
12
13 #include <asm/proc-fns.h>
14 #include <asm/unistd.h>
15 #include <asm/fpu.h>
16
17 #include <linux/ptrace.h>
18 #include <nds32_intrinsic.h>
19
20 extern void show_pte(struct mm_struct *mm, unsigned long addr);
21
22 /*
23 * Dump out the contents of some memory nicely...
24 */
dump_mem(const char * lvl,unsigned long bottom,unsigned long top)25 void dump_mem(const char *lvl, unsigned long bottom, unsigned long top)
26 {
27 unsigned long first;
28 int i;
29
30 pr_emerg("%s(0x%08lx to 0x%08lx)\n", lvl, bottom, top);
31
32 for (first = bottom & ~31; first < top; first += 32) {
33 unsigned long p;
34 char str[sizeof(" 12345678") * 8 + 1];
35
36 memset(str, ' ', sizeof(str));
37 str[sizeof(str) - 1] = '\0';
38
39 for (p = first, i = 0; i < 8 && p < top; i++, p += 4) {
40 if (p >= bottom && p < top) {
41 unsigned long val;
42
43 if (get_kernel_nofault(val,
44 (unsigned long *)p) == 0)
45 sprintf(str + i * 9, " %08lx", val);
46 else
47 sprintf(str + i * 9, " ????????");
48 }
49 }
50 pr_emerg("%s%04lx:%s\n", lvl, first & 0xffff, str);
51 }
52 }
53
54 EXPORT_SYMBOL(dump_mem);
55
56 #define LOOP_TIMES (100)
__dump(struct task_struct * tsk,unsigned long * base_reg,const char * loglvl)57 static void __dump(struct task_struct *tsk, unsigned long *base_reg,
58 const char *loglvl)
59 {
60 unsigned long ret_addr;
61 int cnt = LOOP_TIMES, graph = 0;
62 printk("%sCall Trace:\n", loglvl);
63 if (!IS_ENABLED(CONFIG_FRAME_POINTER)) {
64 while (!kstack_end(base_reg)) {
65 ret_addr = *base_reg++;
66 if (__kernel_text_address(ret_addr)) {
67 ret_addr = ftrace_graph_ret_addr(
68 tsk, &graph, ret_addr, NULL);
69 print_ip_sym(loglvl, ret_addr);
70 }
71 if (--cnt < 0)
72 break;
73 }
74 } else {
75 while (!kstack_end((void *)base_reg) &&
76 !((unsigned long)base_reg & 0x3) &&
77 ((unsigned long)base_reg >= TASK_SIZE)) {
78 unsigned long next_fp;
79 ret_addr = base_reg[LP_OFFSET];
80 next_fp = base_reg[FP_OFFSET];
81 if (__kernel_text_address(ret_addr)) {
82
83 ret_addr = ftrace_graph_ret_addr(
84 tsk, &graph, ret_addr, NULL);
85 print_ip_sym(loglvl, ret_addr);
86 }
87 if (--cnt < 0)
88 break;
89 base_reg = (unsigned long *)next_fp;
90 }
91 }
92 printk("%s\n", loglvl);
93 }
94
show_stack(struct task_struct * tsk,unsigned long * sp,const char * loglvl)95 void show_stack(struct task_struct *tsk, unsigned long *sp, const char *loglvl)
96 {
97 unsigned long *base_reg;
98
99 if (!tsk)
100 tsk = current;
101 if (!IS_ENABLED(CONFIG_FRAME_POINTER)) {
102 if (tsk != current)
103 base_reg = (unsigned long *)(tsk->thread.cpu_context.sp);
104 else
105 __asm__ __volatile__("\tori\t%0, $sp, #0\n":"=r"(base_reg));
106 } else {
107 if (tsk != current)
108 base_reg = (unsigned long *)(tsk->thread.cpu_context.fp);
109 else
110 __asm__ __volatile__("\tori\t%0, $fp, #0\n":"=r"(base_reg));
111 }
112 __dump(tsk, base_reg, loglvl);
113 barrier();
114 }
115
116 DEFINE_SPINLOCK(die_lock);
117
118 /*
119 * This function is protected against re-entrancy.
120 */
die(const char * str,struct pt_regs * regs,int err)121 void die(const char *str, struct pt_regs *regs, int err)
122 {
123 struct task_struct *tsk = current;
124 static int die_counter;
125
126 console_verbose();
127 spin_lock_irq(&die_lock);
128 bust_spinlocks(1);
129
130 pr_emerg("Internal error: %s: %x [#%d]\n", str, err, ++die_counter);
131 print_modules();
132 pr_emerg("CPU: %i\n", smp_processor_id());
133 show_regs(regs);
134 pr_emerg("Process %s (pid: %d, stack limit = 0x%p)\n",
135 tsk->comm, tsk->pid, end_of_stack(tsk));
136
137 if (!user_mode(regs) || in_interrupt()) {
138 dump_mem("Stack: ", regs->sp, (regs->sp + PAGE_SIZE) & PAGE_MASK);
139 dump_stack();
140 }
141
142 bust_spinlocks(0);
143 spin_unlock_irq(&die_lock);
144 make_task_dead(SIGSEGV);
145 }
146
147 EXPORT_SYMBOL(die);
148
die_if_kernel(const char * str,struct pt_regs * regs,int err)149 void die_if_kernel(const char *str, struct pt_regs *regs, int err)
150 {
151 if (user_mode(regs))
152 return;
153
154 die(str, regs, err);
155 }
156
bad_syscall(int n,struct pt_regs * regs)157 int bad_syscall(int n, struct pt_regs *regs)
158 {
159 if (current->personality != PER_LINUX) {
160 send_sig(SIGSEGV, current, 1);
161 return regs->uregs[0];
162 }
163
164 force_sig_fault(SIGILL, ILL_ILLTRP,
165 (void __user *)instruction_pointer(regs) - 4);
166 die_if_kernel("Oops - bad syscall", regs, n);
167 return regs->uregs[0];
168 }
169
__pte_error(const char * file,int line,unsigned long val)170 void __pte_error(const char *file, int line, unsigned long val)
171 {
172 pr_emerg("%s:%d: bad pte %08lx.\n", file, line, val);
173 }
174
__pmd_error(const char * file,int line,unsigned long val)175 void __pmd_error(const char *file, int line, unsigned long val)
176 {
177 pr_emerg("%s:%d: bad pmd %08lx.\n", file, line, val);
178 }
179
__pgd_error(const char * file,int line,unsigned long val)180 void __pgd_error(const char *file, int line, unsigned long val)
181 {
182 pr_emerg("%s:%d: bad pgd %08lx.\n", file, line, val);
183 }
184
185 extern char *exception_vector, *exception_vector_end;
early_trap_init(void)186 void __init early_trap_init(void)
187 {
188 unsigned long ivb = 0;
189 unsigned long base = PAGE_OFFSET;
190
191 memcpy((unsigned long *)base, (unsigned long *)&exception_vector,
192 ((unsigned long)&exception_vector_end -
193 (unsigned long)&exception_vector));
194 ivb = __nds32__mfsr(NDS32_SR_IVB);
195 /* Check platform support. */
196 if (((ivb & IVB_mskNIVIC) >> IVB_offNIVIC) < 2)
197 panic
198 ("IVIC mode is not allowed on the platform with interrupt controller\n");
199 __nds32__mtsr((ivb & ~IVB_mskESZ) | (IVB_valESZ16 << IVB_offESZ) |
200 IVB_BASE, NDS32_SR_IVB);
201 __nds32__mtsr(INT_MASK_INITAIAL_VAL, NDS32_SR_INT_MASK);
202
203 /*
204 * 0x800 = 128 vectors * 16byte.
205 * It should be enough to flush a page.
206 */
207 cpu_cache_wbinval_page(base, true);
208 }
209
send_sigtrap(struct pt_regs * regs,int error_code,int si_code)210 static void send_sigtrap(struct pt_regs *regs, int error_code, int si_code)
211 {
212 struct task_struct *tsk = current;
213
214 tsk->thread.trap_no = ENTRY_DEBUG_RELATED;
215 tsk->thread.error_code = error_code;
216
217 force_sig_fault(SIGTRAP, si_code,
218 (void __user *)instruction_pointer(regs));
219 }
220
do_debug_trap(unsigned long entry,unsigned long addr,unsigned long type,struct pt_regs * regs)221 void do_debug_trap(unsigned long entry, unsigned long addr,
222 unsigned long type, struct pt_regs *regs)
223 {
224 if (notify_die(DIE_OOPS, "Oops", regs, addr, type, SIGTRAP)
225 == NOTIFY_STOP)
226 return;
227
228 if (user_mode(regs)) {
229 /* trap_signal */
230 send_sigtrap(regs, 0, TRAP_BRKPT);
231 } else {
232 /* kernel_trap */
233 if (!fixup_exception(regs))
234 die("unexpected kernel_trap", regs, 0);
235 }
236 }
237
unhandled_interruption(struct pt_regs * regs)238 void unhandled_interruption(struct pt_regs *regs)
239 {
240 pr_emerg("unhandled_interruption\n");
241 show_regs(regs);
242 if (!user_mode(regs))
243 make_task_dead(SIGKILL);
244 force_sig(SIGKILL);
245 }
246
unhandled_exceptions(unsigned long entry,unsigned long addr,unsigned long type,struct pt_regs * regs)247 void unhandled_exceptions(unsigned long entry, unsigned long addr,
248 unsigned long type, struct pt_regs *regs)
249 {
250 pr_emerg("Unhandled Exception: entry: %lx addr:%lx itype:%lx\n", entry,
251 addr, type);
252 show_regs(regs);
253 if (!user_mode(regs))
254 make_task_dead(SIGKILL);
255 force_sig(SIGKILL);
256 }
257
258 extern int do_page_fault(unsigned long entry, unsigned long addr,
259 unsigned int error_code, struct pt_regs *regs);
260
261 /*
262 * 2:DEF dispatch for TLB MISC exception handler
263 */
264
do_dispatch_tlb_misc(unsigned long entry,unsigned long addr,unsigned long type,struct pt_regs * regs)265 void do_dispatch_tlb_misc(unsigned long entry, unsigned long addr,
266 unsigned long type, struct pt_regs *regs)
267 {
268 type = type & (ITYPE_mskINST | ITYPE_mskETYPE);
269 if ((type & ITYPE_mskETYPE) < 5) {
270 /* Permission exceptions */
271 do_page_fault(entry, addr, type, regs);
272 } else
273 unhandled_exceptions(entry, addr, type, regs);
274 }
275
do_revinsn(struct pt_regs * regs)276 void do_revinsn(struct pt_regs *regs)
277 {
278 pr_emerg("Reserved Instruction\n");
279 show_regs(regs);
280 if (!user_mode(regs))
281 make_task_dead(SIGILL);
282 force_sig(SIGILL);
283 }
284
285 #ifdef CONFIG_ALIGNMENT_TRAP
286 extern int unalign_access_mode;
287 extern int do_unaligned_access(unsigned long addr, struct pt_regs *regs);
288 #endif
do_dispatch_general(unsigned long entry,unsigned long addr,unsigned long itype,struct pt_regs * regs,unsigned long oipc)289 void do_dispatch_general(unsigned long entry, unsigned long addr,
290 unsigned long itype, struct pt_regs *regs,
291 unsigned long oipc)
292 {
293 unsigned int swid = itype >> ITYPE_offSWID;
294 unsigned long type = itype & (ITYPE_mskINST | ITYPE_mskETYPE);
295 if (type == ETYPE_ALIGNMENT_CHECK) {
296 #ifdef CONFIG_ALIGNMENT_TRAP
297 /* Alignment check */
298 if (user_mode(regs) && unalign_access_mode) {
299 int ret;
300 ret = do_unaligned_access(addr, regs);
301
302 if (ret == 0)
303 return;
304
305 if (ret == -EFAULT)
306 pr_emerg
307 ("Unhandled unaligned access exception\n");
308 }
309 #endif
310 do_page_fault(entry, addr, type, regs);
311 } else if (type == ETYPE_RESERVED_INSTRUCTION) {
312 /* Reserved instruction */
313 do_revinsn(regs);
314 } else if (type == ETYPE_COPROCESSOR) {
315 /* Coprocessor */
316 #if IS_ENABLED(CONFIG_FPU)
317 unsigned int fucop_exist = __nds32__mfsr(NDS32_SR_FUCOP_EXIST);
318 unsigned int cpid = ((itype & ITYPE_mskCPID) >> ITYPE_offCPID);
319
320 if ((cpid == FPU_CPID) &&
321 (fucop_exist & FUCOP_EXIST_mskCP0ISFPU)) {
322 unsigned int subtype = (itype & ITYPE_mskSTYPE);
323
324 if (true == do_fpu_exception(subtype, regs))
325 return;
326 }
327 #endif
328 unhandled_exceptions(entry, addr, type, regs);
329 } else if (type == ETYPE_TRAP && swid == SWID_RAISE_INTERRUPT_LEVEL) {
330 /* trap, used on v3 EDM target debugging workaround */
331 /*
332 * DIPC(OIPC) is passed as parameter before
333 * interrupt is enabled, so the DIPC will not be corrupted
334 * even though interrupts are coming in
335 */
336 /*
337 * 1. update ipc
338 * 2. update pt_regs ipc with oipc
339 * 3. update pt_regs ipsw (clear DEX)
340 */
341 __asm__ volatile ("mtsr %0, $IPC\n\t"::"r" (oipc));
342 regs->ipc = oipc;
343 if (regs->pipsw & PSW_mskDEX) {
344 pr_emerg
345 ("Nested Debug exception is possibly happened\n");
346 pr_emerg("ipc:%08x pipc:%08x\n",
347 (unsigned int)regs->ipc,
348 (unsigned int)regs->pipc);
349 }
350 do_debug_trap(entry, addr, itype, regs);
351 regs->ipsw &= ~PSW_mskDEX;
352 } else
353 unhandled_exceptions(entry, addr, type, regs);
354 }
355