1
2
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
12#include <asm/proc-fns.h>
13#include <asm/unistd.h>
14
15#include <linux/ptrace.h>
16#include <nds32_intrinsic.h>
17
18extern void show_pte(struct mm_struct *mm, unsigned long addr);
19
20
21
22
23void dump_mem(const char *lvl, unsigned long bottom, unsigned long top)
24{
25 unsigned long first;
26 mm_segment_t fs;
27 int i;
28
29
30
31
32
33
34 fs = get_fs();
35 set_fs(KERNEL_DS);
36
37 pr_emerg("%s(0x%08lx to 0x%08lx)\n", lvl, bottom, top);
38
39 for (first = bottom & ~31; first < top; first += 32) {
40 unsigned long p;
41 char str[sizeof(" 12345678") * 8 + 1];
42
43 memset(str, ' ', sizeof(str));
44 str[sizeof(str) - 1] = '\0';
45
46 for (p = first, i = 0; i < 8 && p < top; i++, p += 4) {
47 if (p >= bottom && p < top) {
48 unsigned long val;
49 if (__get_user(val, (unsigned long *)p) == 0)
50 sprintf(str + i * 9, " %08lx", val);
51 else
52 sprintf(str + i * 9, " ????????");
53 }
54 }
55 pr_emerg("%s%04lx:%s\n", lvl, first & 0xffff, str);
56 }
57
58 set_fs(fs);
59}
60
61EXPORT_SYMBOL(dump_mem);
62
63static void dump_instr(struct pt_regs *regs)
64{
65 unsigned long addr = instruction_pointer(regs);
66 mm_segment_t fs;
67 char str[sizeof("00000000 ") * 5 + 2 + 1], *p = str;
68 int i;
69
70 return;
71
72
73
74
75
76 fs = get_fs();
77 set_fs(KERNEL_DS);
78
79 pr_emerg("Code: ");
80 for (i = -4; i < 1; i++) {
81 unsigned int val, bad;
82
83 bad = __get_user(val, &((u32 *) addr)[i]);
84
85 if (!bad) {
86 p += sprintf(p, i == 0 ? "(%08x) " : "%08x ", val);
87 } else {
88 p += sprintf(p, "bad PC value");
89 break;
90 }
91 }
92 pr_emerg("Code: %s\n", str);
93
94 set_fs(fs);
95}
96
97#ifdef CONFIG_FUNCTION_GRAPH_TRACER
98#include <linux/ftrace.h>
99static void
100get_real_ret_addr(unsigned long *addr, struct task_struct *tsk, int *graph)
101{
102 if (*addr == (unsigned long)return_to_handler) {
103 int index = tsk->curr_ret_stack;
104
105 if (tsk->ret_stack && index >= *graph) {
106 index -= *graph;
107 *addr = tsk->ret_stack[index].ret;
108 (*graph)++;
109 }
110 }
111}
112#else
113static inline void
114get_real_ret_addr(unsigned long *addr, struct task_struct *tsk, int *graph)
115{
116}
117#endif
118
119#define LOOP_TIMES (100)
120static void __dump(struct task_struct *tsk, unsigned long *base_reg)
121{
122 unsigned long ret_addr;
123 int cnt = LOOP_TIMES, graph = 0;
124 pr_emerg("Call Trace:\n");
125 if (!IS_ENABLED(CONFIG_FRAME_POINTER)) {
126 while (!kstack_end(base_reg)) {
127 ret_addr = *base_reg++;
128 if (__kernel_text_address(ret_addr)) {
129 get_real_ret_addr(&ret_addr, tsk, &graph);
130 print_ip_sym(ret_addr);
131 }
132 if (--cnt < 0)
133 break;
134 }
135 } else {
136 while (!kstack_end((void *)base_reg) &&
137 !((unsigned long)base_reg & 0x3) &&
138 ((unsigned long)base_reg >= TASK_SIZE)) {
139 unsigned long next_fp;
140#if !defined(NDS32_ABI_2)
141 ret_addr = base_reg[0];
142 next_fp = base_reg[1];
143#else
144 ret_addr = base_reg[-1];
145 next_fp = base_reg[FP_OFFSET];
146#endif
147 if (__kernel_text_address(ret_addr)) {
148 get_real_ret_addr(&ret_addr, tsk, &graph);
149 print_ip_sym(ret_addr);
150 }
151 if (--cnt < 0)
152 break;
153 base_reg = (unsigned long *)next_fp;
154 }
155 }
156 pr_emerg("\n");
157}
158
159void show_stack(struct task_struct *tsk, unsigned long *sp)
160{
161 unsigned long *base_reg;
162
163 if (!tsk)
164 tsk = current;
165 if (!IS_ENABLED(CONFIG_FRAME_POINTER)) {
166 if (tsk != current)
167 base_reg = (unsigned long *)(tsk->thread.cpu_context.sp);
168 else
169 __asm__ __volatile__("\tori\t%0, $sp, #0\n":"=r"(base_reg));
170 } else {
171 if (tsk != current)
172 base_reg = (unsigned long *)(tsk->thread.cpu_context.fp);
173 else
174 __asm__ __volatile__("\tori\t%0, $fp, #0\n":"=r"(base_reg));
175 }
176 __dump(tsk, base_reg);
177 barrier();
178}
179
180DEFINE_SPINLOCK(die_lock);
181
182
183
184
185void die(const char *str, struct pt_regs *regs, int err)
186{
187 struct task_struct *tsk = current;
188 static int die_counter;
189
190 console_verbose();
191 spin_lock_irq(&die_lock);
192 bust_spinlocks(1);
193
194 pr_emerg("Internal error: %s: %x [#%d]\n", str, err, ++die_counter);
195 print_modules();
196 pr_emerg("CPU: %i\n", smp_processor_id());
197 show_regs(regs);
198 pr_emerg("Process %s (pid: %d, stack limit = 0x%p)\n",
199 tsk->comm, tsk->pid, task_thread_info(tsk) + 1);
200
201 if (!user_mode(regs) || in_interrupt()) {
202 dump_mem("Stack: ", regs->sp,
203 THREAD_SIZE + (unsigned long)task_thread_info(tsk));
204 dump_instr(regs);
205 dump_stack();
206 }
207
208 bust_spinlocks(0);
209 spin_unlock_irq(&die_lock);
210 do_exit(SIGSEGV);
211}
212
213EXPORT_SYMBOL(die);
214
215void die_if_kernel(const char *str, struct pt_regs *regs, int err)
216{
217 if (user_mode(regs))
218 return;
219
220 die(str, regs, err);
221}
222
223int bad_syscall(int n, struct pt_regs *regs)
224{
225 if (current->personality != PER_LINUX) {
226 send_sig(SIGSEGV, current, 1);
227 return regs->uregs[0];
228 }
229
230 force_sig_fault(SIGILL, ILL_ILLTRP,
231 (void __user *)instruction_pointer(regs) - 4, current);
232 die_if_kernel("Oops - bad syscall", regs, n);
233 return regs->uregs[0];
234}
235
236void __pte_error(const char *file, int line, unsigned long val)
237{
238 pr_emerg("%s:%d: bad pte %08lx.\n", file, line, val);
239}
240
241void __pmd_error(const char *file, int line, unsigned long val)
242{
243 pr_emerg("%s:%d: bad pmd %08lx.\n", file, line, val);
244}
245
246void __pgd_error(const char *file, int line, unsigned long val)
247{
248 pr_emerg("%s:%d: bad pgd %08lx.\n", file, line, val);
249}
250
251extern char *exception_vector, *exception_vector_end;
252void __init trap_init(void)
253{
254 return;
255}
256
257void __init early_trap_init(void)
258{
259 unsigned long ivb = 0;
260 unsigned long base = PAGE_OFFSET;
261
262 memcpy((unsigned long *)base, (unsigned long *)&exception_vector,
263 ((unsigned long)&exception_vector_end -
264 (unsigned long)&exception_vector));
265 ivb = __nds32__mfsr(NDS32_SR_IVB);
266
267 if (((ivb & IVB_mskNIVIC) >> IVB_offNIVIC) < 2)
268 panic
269 ("IVIC mode is not allowed on the platform with interrupt controller\n");
270 __nds32__mtsr((ivb & ~IVB_mskESZ) | (IVB_valESZ16 << IVB_offESZ) |
271 IVB_BASE, NDS32_SR_IVB);
272 __nds32__mtsr(INT_MASK_INITAIAL_VAL, NDS32_SR_INT_MASK);
273
274
275
276
277
278 cpu_cache_wbinval_page(base, true);
279}
280
281void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs,
282 int error_code, int si_code)
283{
284 tsk->thread.trap_no = ENTRY_DEBUG_RELATED;
285 tsk->thread.error_code = error_code;
286
287 force_sig_fault(SIGTRAP, si_code,
288 (void __user *)instruction_pointer(regs), tsk);
289}
290
291void do_debug_trap(unsigned long entry, unsigned long addr,
292 unsigned long type, struct pt_regs *regs)
293{
294 if (notify_die(DIE_OOPS, "Oops", regs, addr, type, SIGTRAP)
295 == NOTIFY_STOP)
296 return;
297
298 if (user_mode(regs)) {
299
300 send_sigtrap(current, regs, 0, TRAP_BRKPT);
301 } else {
302
303 if (!fixup_exception(regs))
304 die("unexpected kernel_trap", regs, 0);
305 }
306}
307
308void unhandled_interruption(struct pt_regs *regs)
309{
310 pr_emerg("unhandled_interruption\n");
311 show_regs(regs);
312 if (!user_mode(regs))
313 do_exit(SIGKILL);
314 force_sig(SIGKILL, current);
315}
316
317void unhandled_exceptions(unsigned long entry, unsigned long addr,
318 unsigned long type, struct pt_regs *regs)
319{
320 pr_emerg("Unhandled Exception: entry: %lx addr:%lx itype:%lx\n", entry,
321 addr, type);
322 show_regs(regs);
323 if (!user_mode(regs))
324 do_exit(SIGKILL);
325 force_sig(SIGKILL, current);
326}
327
328extern int do_page_fault(unsigned long entry, unsigned long addr,
329 unsigned int error_code, struct pt_regs *regs);
330
331
332
333
334
335void do_dispatch_tlb_misc(unsigned long entry, unsigned long addr,
336 unsigned long type, struct pt_regs *regs)
337{
338 type = type & (ITYPE_mskINST | ITYPE_mskETYPE);
339 if ((type & ITYPE_mskETYPE) < 5) {
340
341 do_page_fault(entry, addr, type, regs);
342 } else
343 unhandled_exceptions(entry, addr, type, regs);
344}
345
346void do_revinsn(struct pt_regs *regs)
347{
348 pr_emerg("Reserved Instruction\n");
349 show_regs(regs);
350 if (!user_mode(regs))
351 do_exit(SIGILL);
352 force_sig(SIGILL, current);
353}
354
355#ifdef CONFIG_ALIGNMENT_TRAP
356extern int unalign_access_mode;
357extern int do_unaligned_access(unsigned long addr, struct pt_regs *regs);
358#endif
359void do_dispatch_general(unsigned long entry, unsigned long addr,
360 unsigned long itype, struct pt_regs *regs,
361 unsigned long oipc)
362{
363 unsigned int swid = itype >> ITYPE_offSWID;
364 unsigned long type = itype & (ITYPE_mskINST | ITYPE_mskETYPE);
365 if (type == ETYPE_ALIGNMENT_CHECK) {
366#ifdef CONFIG_ALIGNMENT_TRAP
367
368 if (user_mode(regs) && unalign_access_mode) {
369 int ret;
370 ret = do_unaligned_access(addr, regs);
371
372 if (ret == 0)
373 return;
374
375 if (ret == -EFAULT)
376 pr_emerg
377 ("Unhandled unaligned access exception\n");
378 }
379#endif
380 do_page_fault(entry, addr, type, regs);
381 } else if (type == ETYPE_RESERVED_INSTRUCTION) {
382
383 do_revinsn(regs);
384 } else if (type == ETYPE_TRAP && swid == SWID_RAISE_INTERRUPT_LEVEL) {
385
386
387
388
389
390
391
392
393
394
395
396 __asm__ volatile ("mtsr %0, $IPC\n\t"::"r" (oipc));
397 regs->ipc = oipc;
398 if (regs->pipsw & PSW_mskDEX) {
399 pr_emerg
400 ("Nested Debug exception is possibly happened\n");
401 pr_emerg("ipc:%08x pipc:%08x\n",
402 (unsigned int)regs->ipc,
403 (unsigned int)regs->pipc);
404 }
405 do_debug_trap(entry, addr, itype, regs);
406 regs->ipsw &= ~PSW_mskDEX;
407 } else
408 unhandled_exceptions(entry, addr, type, regs);
409}
410
