]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - arch/openrisc/kernel/traps.c
4 * Linux architectural port borrowing liberally from similar works of
5 * others. All original copyrights apply as per the original source
8 * Modifications for the OpenRISC architecture:
9 * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com>
10 * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se>
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
17 * Here we handle the break vectors not used by the system call
18 * mechanism, as well as some general stack/register dumping
23 #include <linux/init.h>
24 #include <linux/sched.h>
25 #include <linux/sched/debug.h>
26 #include <linux/sched/task_stack.h>
27 #include <linux/kernel.h>
28 #include <linux/extable.h>
29 #include <linux/kmod.h>
30 #include <linux/string.h>
31 #include <linux/errno.h>
32 #include <linux/ptrace.h>
33 #include <linux/timer.h>
35 #include <linux/kallsyms.h>
36 #include <linux/uaccess.h>
38 #include <asm/segment.h>
40 #include <asm/pgtable.h>
41 #include <asm/unwinder.h>
43 extern char _etext
, _stext
;
45 int kstack_depth_to_print
= 0x180;
47 unsigned long __user
*lwa_addr
;
49 void print_trace(void *data
, unsigned long addr
, int reliable
)
51 pr_emerg("[<%p>] %s%pS\n", (void *) addr
, reliable
? "" : "? ",
55 /* displays a short stack trace */
56 void show_stack(struct task_struct
*task
, unsigned long *esp
)
59 esp
= (unsigned long *)&esp
;
61 pr_emerg("Call trace:\n");
62 unwind_stack(NULL
, esp
, print_trace
);
65 void show_trace_task(struct task_struct
*tsk
)
68 * TODO: SysRq-T trace dump...
72 void show_registers(struct pt_regs
*regs
)
78 esp
= (unsigned long)(regs
->sp
);
83 " PC: %08lx SR: %08lx SP: %08lx\n",
84 smp_processor_id(), regs
->pc
, regs
->sr
, regs
->sp
);
85 printk("GPR00: %08lx GPR01: %08lx GPR02: %08lx GPR03: %08lx\n",
86 0L, regs
->gpr
[1], regs
->gpr
[2], regs
->gpr
[3]);
87 printk("GPR04: %08lx GPR05: %08lx GPR06: %08lx GPR07: %08lx\n",
88 regs
->gpr
[4], regs
->gpr
[5], regs
->gpr
[6], regs
->gpr
[7]);
89 printk("GPR08: %08lx GPR09: %08lx GPR10: %08lx GPR11: %08lx\n",
90 regs
->gpr
[8], regs
->gpr
[9], regs
->gpr
[10], regs
->gpr
[11]);
91 printk("GPR12: %08lx GPR13: %08lx GPR14: %08lx GPR15: %08lx\n",
92 regs
->gpr
[12], regs
->gpr
[13], regs
->gpr
[14], regs
->gpr
[15]);
93 printk("GPR16: %08lx GPR17: %08lx GPR18: %08lx GPR19: %08lx\n",
94 regs
->gpr
[16], regs
->gpr
[17], regs
->gpr
[18], regs
->gpr
[19]);
95 printk("GPR20: %08lx GPR21: %08lx GPR22: %08lx GPR23: %08lx\n",
96 regs
->gpr
[20], regs
->gpr
[21], regs
->gpr
[22], regs
->gpr
[23]);
97 printk("GPR24: %08lx GPR25: %08lx GPR26: %08lx GPR27: %08lx\n",
98 regs
->gpr
[24], regs
->gpr
[25], regs
->gpr
[26], regs
->gpr
[27]);
99 printk("GPR28: %08lx GPR29: %08lx GPR30: %08lx GPR31: %08lx\n",
100 regs
->gpr
[28], regs
->gpr
[29], regs
->gpr
[30], regs
->gpr
[31]);
101 printk(" RES: %08lx oGPR11: %08lx\n",
102 regs
->gpr
[11], regs
->orig_gpr11
);
104 printk("Process %s (pid: %d, stackpage=%08lx)\n",
105 current
->comm
, current
->pid
, (unsigned long)current
);
107 * When in-kernel, we also print out the stack and code at the
108 * time of the fault..
113 show_stack(NULL
, (unsigned long *)esp
);
116 if (regs
->pc
< PAGE_OFFSET
)
119 for (i
= -24; i
< 24; i
++) {
121 if (__get_user(c
, &((unsigned char *)regs
->pc
)[i
])) {
123 printk(" Bad PC value.");
128 printk("(%02x) ", c
);
136 void nommu_dump_state(struct pt_regs
*regs
,
137 unsigned long ea
, unsigned long vector
)
140 unsigned long addr
, stack
= regs
->sp
;
142 printk("\n\r[nommu_dump_state] :: ea %lx, vector %lx\n\r", ea
, vector
);
145 " PC: %08lx SR: %08lx SP: %08lx\n",
146 0, regs
->pc
, regs
->sr
, regs
->sp
);
147 printk("GPR00: %08lx GPR01: %08lx GPR02: %08lx GPR03: %08lx\n",
148 0L, regs
->gpr
[1], regs
->gpr
[2], regs
->gpr
[3]);
149 printk("GPR04: %08lx GPR05: %08lx GPR06: %08lx GPR07: %08lx\n",
150 regs
->gpr
[4], regs
->gpr
[5], regs
->gpr
[6], regs
->gpr
[7]);
151 printk("GPR08: %08lx GPR09: %08lx GPR10: %08lx GPR11: %08lx\n",
152 regs
->gpr
[8], regs
->gpr
[9], regs
->gpr
[10], regs
->gpr
[11]);
153 printk("GPR12: %08lx GPR13: %08lx GPR14: %08lx GPR15: %08lx\n",
154 regs
->gpr
[12], regs
->gpr
[13], regs
->gpr
[14], regs
->gpr
[15]);
155 printk("GPR16: %08lx GPR17: %08lx GPR18: %08lx GPR19: %08lx\n",
156 regs
->gpr
[16], regs
->gpr
[17], regs
->gpr
[18], regs
->gpr
[19]);
157 printk("GPR20: %08lx GPR21: %08lx GPR22: %08lx GPR23: %08lx\n",
158 regs
->gpr
[20], regs
->gpr
[21], regs
->gpr
[22], regs
->gpr
[23]);
159 printk("GPR24: %08lx GPR25: %08lx GPR26: %08lx GPR27: %08lx\n",
160 regs
->gpr
[24], regs
->gpr
[25], regs
->gpr
[26], regs
->gpr
[27]);
161 printk("GPR28: %08lx GPR29: %08lx GPR30: %08lx GPR31: %08lx\n",
162 regs
->gpr
[28], regs
->gpr
[29], regs
->gpr
[30], regs
->gpr
[31]);
163 printk(" RES: %08lx oGPR11: %08lx\n",
164 regs
->gpr
[11], regs
->orig_gpr11
);
166 printk("Process %s (pid: %d, stackpage=%08lx)\n",
167 ((struct task_struct
*)(__pa(current
)))->comm
,
168 ((struct task_struct
*)(__pa(current
)))->pid
,
169 (unsigned long)current
);
172 printk("Stack dump [0x%08lx]:\n", (unsigned long)stack
);
173 for (i
= 0; i
< kstack_depth_to_print
; i
++) {
174 if (((long)stack
& (THREAD_SIZE
- 1)) == 0)
178 printk("%lx :: sp + %02d: 0x%08lx\n", stack
, i
* 4,
179 *((unsigned long *)(__pa(stack
))));
183 printk("Call Trace: ");
185 while (((long)stack
& (THREAD_SIZE
- 1)) != 0) {
186 addr
= *((unsigned long *)__pa(stack
));
189 if (kernel_text_address(addr
)) {
190 if (i
&& ((i
% 6) == 0))
192 printk(" [<%08lx>]", addr
);
200 for (i
= -24; i
< 24; i
++) {
202 c
= ((unsigned char *)(__pa(regs
->pc
)))[i
];
205 printk("(%02x) ", c
);
212 /* This is normally the 'Oops' routine */
213 void die(const char *str
, struct pt_regs
*regs
, long err
)
217 printk("\n%s#: %04lx\n", str
, err
& 0xffff);
218 show_registers(regs
);
219 #ifdef CONFIG_JUMP_UPON_UNHANDLED_EXCEPTION
220 printk("\n\nUNHANDLED_EXCEPTION: entering infinite loop\n");
222 /* shut down interrupts */
225 __asm__
__volatile__("l.nop 1");
231 /* This is normally the 'Oops' routine */
232 void die_if_kernel(const char *str
, struct pt_regs
*regs
, long err
)
240 void unhandled_exception(struct pt_regs
*regs
, int ea
, int vector
)
242 printk("Unable to handle exception at EA =0x%x, vector 0x%x",
244 die("Oops", regs
, 9);
247 void __init
trap_init(void)
249 /* Nothing needs to be done */
252 asmlinkage
void do_trap(struct pt_regs
*regs
, unsigned long address
)
255 memset(&info
, 0, sizeof(info
));
256 info
.si_signo
= SIGTRAP
;
257 info
.si_code
= TRAP_TRACE
;
258 info
.si_addr
= (void *)address
;
259 force_sig_info(SIGTRAP
, &info
, current
);
264 asmlinkage
void do_unaligned_access(struct pt_regs
*regs
, unsigned long address
)
268 if (user_mode(regs
)) {
270 info
.si_signo
= SIGSEGV
;
272 /* info.si_code has been set above */
273 info
.si_addr
= (void *)address
;
274 force_sig_info(SIGSEGV
, &info
, current
);
276 printk("KERNEL: Unaligned Access 0x%.8lx\n", address
);
277 show_registers(regs
);
278 die("Die:", regs
, address
);
283 asmlinkage
void do_bus_fault(struct pt_regs
*regs
, unsigned long address
)
287 if (user_mode(regs
)) {
289 info
.si_signo
= SIGBUS
;
291 info
.si_code
= BUS_ADRERR
;
292 info
.si_addr
= (void *)address
;
293 force_sig_info(SIGBUS
, &info
, current
);
294 } else { /* Kernel mode */
295 printk("KERNEL: Bus error (SIGBUS) 0x%.8lx\n", address
);
296 show_registers(regs
);
297 die("Die:", regs
, address
);
301 static inline int in_delay_slot(struct pt_regs
*regs
)
303 #ifdef CONFIG_OPENRISC_NO_SPR_SR_DSX
304 /* No delay slot flag, do the old way */
305 unsigned int op
, insn
;
307 insn
= *((unsigned int *)regs
->pc
);
311 case 0x01: /* l.jal */
312 case 0x03: /* l.bnf */
313 case 0x04: /* l.bf */
314 case 0x11: /* l.jr */
315 case 0x12: /* l.jalr */
321 return regs
->sr
& SPR_SR_DSX
;
325 static inline void adjust_pc(struct pt_regs
*regs
, unsigned long address
)
328 unsigned int rb
, op
, jmp
;
330 if (unlikely(in_delay_slot(regs
))) {
331 /* In delay slot, instruction at pc is a branch, simulate it */
332 jmp
= *((unsigned int *)regs
->pc
);
334 displacement
= sign_extend32(((jmp
) & 0x3ffffff) << 2, 27);
335 rb
= (jmp
& 0x0000ffff) >> 11;
340 regs
->pc
+= displacement
;
342 case 0x01: /* l.jal */
343 regs
->pc
+= displacement
;
344 regs
->gpr
[9] = regs
->pc
+ 8;
346 case 0x03: /* l.bnf */
347 if (regs
->sr
& SPR_SR_F
)
350 regs
->pc
+= displacement
;
352 case 0x04: /* l.bf */
353 if (regs
->sr
& SPR_SR_F
)
354 regs
->pc
+= displacement
;
358 case 0x11: /* l.jr */
359 regs
->pc
= regs
->gpr
[rb
];
361 case 0x12: /* l.jalr */
362 regs
->pc
= regs
->gpr
[rb
];
363 regs
->gpr
[9] = regs
->pc
+ 8;
373 static inline void simulate_lwa(struct pt_regs
*regs
, unsigned long address
,
378 unsigned long orig_pc
;
381 const struct exception_table_entry
*entry
;
384 adjust_pc(regs
, address
);
386 ra
= (insn
>> 16) & 0x1f;
387 rd
= (insn
>> 21) & 0x1f;
389 lwa_addr
= (unsigned long __user
*)(regs
->gpr
[ra
] + imm
);
391 if ((unsigned long)lwa_addr
& 0x3) {
392 do_unaligned_access(regs
, address
);
396 if (get_user(value
, lwa_addr
)) {
397 if (user_mode(regs
)) {
398 force_sig(SIGSEGV
, current
);
402 if ((entry
= search_exception_tables(orig_pc
))) {
403 regs
->pc
= entry
->fixup
;
407 /* kernel access in kernel space, load it directly */
408 value
= *((unsigned long *)lwa_addr
);
412 regs
->gpr
[rd
] = value
;
415 static inline void simulate_swa(struct pt_regs
*regs
, unsigned long address
,
418 unsigned long __user
*vaddr
;
419 unsigned long orig_pc
;
423 const struct exception_table_entry
*entry
;
426 adjust_pc(regs
, address
);
428 ra
= (insn
>> 16) & 0x1f;
429 rb
= (insn
>> 11) & 0x1f;
430 imm
= (short)(((insn
& 0x2200000) >> 10) | (insn
& 0x7ff));
431 vaddr
= (unsigned long __user
*)(regs
->gpr
[ra
] + imm
);
433 if (!lwa_flag
|| vaddr
!= lwa_addr
) {
434 regs
->sr
&= ~SPR_SR_F
;
438 if ((unsigned long)vaddr
& 0x3) {
439 do_unaligned_access(regs
, address
);
443 if (put_user(regs
->gpr
[rb
], vaddr
)) {
444 if (user_mode(regs
)) {
445 force_sig(SIGSEGV
, current
);
449 if ((entry
= search_exception_tables(orig_pc
))) {
450 regs
->pc
= entry
->fixup
;
454 /* kernel access in kernel space, store it directly */
455 *((unsigned long *)vaddr
) = regs
->gpr
[rb
];
459 regs
->sr
|= SPR_SR_F
;
462 #define INSN_LWA 0x1b
463 #define INSN_SWA 0x33
465 asmlinkage
void do_illegal_instruction(struct pt_regs
*regs
,
466 unsigned long address
)
470 unsigned int insn
= *((unsigned int *)address
);
476 simulate_lwa(regs
, address
, insn
);
480 simulate_swa(regs
, address
, insn
);
487 if (user_mode(regs
)) {
489 info
.si_signo
= SIGILL
;
491 info
.si_code
= ILL_ILLOPC
;
492 info
.si_addr
= (void *)address
;
493 force_sig_info(SIGBUS
, &info
, current
);
494 } else { /* Kernel mode */
495 printk("KERNEL: Illegal instruction (SIGILL) 0x%.8lx\n",
497 show_registers(regs
);
498 die("Die:", regs
, address
);