projects/linux·blob master · refs

432 lines · 9.9 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Kernel traps/events for Hexagon processor
4 *
5 * Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
6 */
7
8#include <linux/init.h>
9#include <linux/sched/signal.h>
10#include <linux/sched/debug.h>
11#include <linux/sched/task_stack.h>
12#include <linux/module.h>
13#include <linux/kallsyms.h>
14#include <linux/kdebug.h>
15#include <linux/syscalls.h>
16#include <linux/signal.h>
17#include <linux/ptrace.h>
18#include <asm/traps.h>
19#include <asm/vm_fault.h>
20#include <asm/syscall.h>
21#include <asm/registers.h>
22#include <asm/unistd.h>
23#include <asm/sections.h>
24#ifdef CONFIG_KGDB
25# include <linux/kgdb.h>
26#endif
27
28#define TRAP_SYSCALL 1
29#define TRAP_DEBUG 0xdb
30
31#ifdef CONFIG_GENERIC_BUG
32/* Maybe should resemble arch/sh/kernel/traps.c ?? */
33int is_valid_bugaddr(unsigned long addr)
34{
35 return 1;
36}
37#endif /* CONFIG_GENERIC_BUG */
38
39static const char *ex_name(int ex)
40{
41 switch (ex) {
42 case HVM_GE_C_XPROT:
43 case HVM_GE_C_XUSER:
44 return "Execute protection fault";
45 case HVM_GE_C_RPROT:
46 case HVM_GE_C_RUSER:
47 return "Read protection fault";
48 case HVM_GE_C_WPROT:
49 case HVM_GE_C_WUSER:
50 return "Write protection fault";
51 case HVM_GE_C_XMAL:
52 return "Misaligned instruction";
53 case HVM_GE_C_WREG:
54 return "Multiple writes to same register in packet";
55 case HVM_GE_C_PCAL:
56 return "Program counter values that are not properly aligned";
57 case HVM_GE_C_RMAL:
58 return "Misaligned data load";
59 case HVM_GE_C_WMAL:
60 return "Misaligned data store";
61 case HVM_GE_C_INVI:
62 case HVM_GE_C_PRIVI:
63 return "Illegal instruction";
64 case HVM_GE_C_BUS:
65 return "Precise bus error";
66 case HVM_GE_C_CACHE:
67 return "Cache error";
68
69 case 0xdb:
70 return "Debugger trap";
71
72 default:
73 return "Unrecognized exception";
74 }
75}
76
77static void do_show_stack(struct task_struct *task, unsigned long *fp,
78 unsigned long ip, const char *loglvl)
79{
80 int kstack_depth_to_print = 24;
81 unsigned long offset, size;
82 const char *name = NULL;
83 unsigned long *newfp;
84 unsigned long low, high;
85 char tmpstr[128];
86 char *modname;
87 int i;
88
89 if (task == NULL)
90 task = current;
91
92 printk("%sCPU#%d, %s/%d, Call Trace:\n", loglvl, raw_smp_processor_id(),
93 task->comm, task_pid_nr(task));
94
95 if (fp == NULL) {
96 if (task == current) {
97 asm("%0 = r30" : "=r" (fp));
98 } else {
99 fp = (unsigned long *)
100 ((struct hexagon_switch_stack *)
101 task->thread.switch_sp)->fp;
102 }
103 }
104
105 if ((((unsigned long) fp) & 0x3) || ((unsigned long) fp < 0x1000)) {
106 printk("%s-- Corrupt frame pointer %p\n", loglvl, fp);
107 return;
108 }
109
110 /* Saved link reg is one word above FP */
111 if (!ip)
112 ip = *(fp+1);
113
114 /* Expect kernel stack to be in-bounds */
115 low = (unsigned long)task_stack_page(task);
116 high = low + THREAD_SIZE - 8;
117 low += sizeof(struct thread_info);
118
119 for (i = 0; i < kstack_depth_to_print; i++) {
120
121 name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr);
122
123 printk("%s[%p] 0x%lx: %s + 0x%lx", loglvl, fp, ip, name, offset);
124 if (((unsigned long) fp < low) || (high < (unsigned long) fp))
125 printk(KERN_CONT " (FP out of bounds!)");
126 if (modname)
127 printk(KERN_CONT " [%s] ", modname);
128 printk(KERN_CONT "\n");
129
130 newfp = (unsigned long *) *fp;
131
132 if (((unsigned long) newfp) & 0x3) {
133 printk("%s-- Corrupt frame pointer %p\n", loglvl, newfp);
134 break;
135 }
136
137 /* Attempt to continue past exception. */
138 if (!newfp) {
139 struct pt_regs *regs = (struct pt_regs *) (((void *)fp)
140 + 8);
141
142 if (regs->syscall_nr != -1) {
143 printk("%s-- trap0 -- syscall_nr: %ld", loglvl,
144 regs->syscall_nr);
145 printk(KERN_CONT " psp: %lx elr: %lx\n",
146 pt_psp(regs), pt_elr(regs));
147 break;
148 } else {
149 /* really want to see more ... */
150 kstack_depth_to_print += 6;
151 printk("%s-- %s (0x%lx) badva: %lx\n", loglvl,
152 ex_name(pt_cause(regs)), pt_cause(regs),
153 pt_badva(regs));
154 }
155
156 newfp = (unsigned long *) regs->r30;
157 ip = pt_elr(regs);
158 } else {
159 ip = *(newfp + 1);
160 }
161
162 /* If link reg is null, we are done. */
163 if (ip == 0x0)
164 break;
165
166 /* If newfp isn't larger, we're tracing garbage. */
167 if (newfp > fp)
168 fp = newfp;
169 else
170 break;
171 }
172}
173
174void show_stack(struct task_struct *task, unsigned long *fp, const char *loglvl)
175{
176 /* Saved link reg is one word above FP */
177 do_show_stack(task, fp, 0, loglvl);
178}
179
180int die(const char *str, struct pt_regs *regs, long err)
181{
182 static struct {
183 spinlock_t lock;
184 int counter;
185 } die = {
186 .lock = __SPIN_LOCK_UNLOCKED(die.lock),
187 .counter = 0
188 };
189
190 console_verbose();
191 oops_enter();
192
193 spin_lock_irq(&die.lock);
194 bust_spinlocks(1);
195 printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter);
196
197 if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) ==
198 NOTIFY_STOP) {
199 spin_unlock_irq(&die.lock);
200 return 1;
201 }
202
203 print_modules();
204 show_regs(regs);
205 do_show_stack(current, &regs->r30, pt_elr(regs), KERN_EMERG);
206
207 bust_spinlocks(0);
208 add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
209
210 spin_unlock_irq(&die.lock);
211
212 if (in_interrupt())
213 panic("Fatal exception in interrupt");
214
215 if (panic_on_oops)
216 panic("Fatal exception");
217
218 oops_exit();
219 make_task_dead(err);
220 return 0;
221}
222
223int die_if_kernel(char *str, struct pt_regs *regs, long err)
224{
225 if (!user_mode(regs))
226 return die(str, regs, err);
227 else
228 return 0;
229}
230
231/*
232 * It's not clear that misaligned fetches are ever recoverable.
233 */
234static void misaligned_instruction(struct pt_regs *regs)
235{
236 die_if_kernel("Misaligned Instruction", regs, 0);
237 force_sig(SIGBUS);
238}
239
240/*
241 * Misaligned loads and stores, on the other hand, can be
242 * emulated, and probably should be, some day. But for now
243 * they will be considered fatal.
244 */
245static void misaligned_data_load(struct pt_regs *regs)
246{
247 die_if_kernel("Misaligned Data Load", regs, 0);
248 force_sig(SIGBUS);
249}
250
251static void misaligned_data_store(struct pt_regs *regs)
252{
253 die_if_kernel("Misaligned Data Store", regs, 0);
254 force_sig(SIGBUS);
255}
256
257static void illegal_instruction(struct pt_regs *regs)
258{
259 die_if_kernel("Illegal Instruction", regs, 0);
260 force_sig(SIGILL);
261}
262
263/*
264 * Precise bus errors may be recoverable with a a retry,
265 * but for now, treat them as irrecoverable.
266 */
267static void precise_bus_error(struct pt_regs *regs)
268{
269 die_if_kernel("Precise Bus Error", regs, 0);
270 force_sig(SIGBUS);
271}
272
273/*
274 * If anything is to be done here other than panic,
275 * it will probably be complex and migrate to another
276 * source module. For now, just die.
277 */
278static void cache_error(struct pt_regs *regs)
279{
280 die("Cache Error", regs, 0);
281}
282
283/*
284 * General exception handler
285 */
286void do_genex(struct pt_regs *regs);
287void do_genex(struct pt_regs *regs)
288{
289 /*
290 * Decode Cause and Dispatch
291 */
292 switch (pt_cause(regs)) {
293 case HVM_GE_C_XPROT:
294 case HVM_GE_C_XUSER:
295 execute_protection_fault(regs);
296 break;
297 case HVM_GE_C_RPROT:
298 case HVM_GE_C_RUSER:
299 read_protection_fault(regs);
300 break;
301 case HVM_GE_C_WPROT:
302 case HVM_GE_C_WUSER:
303 write_protection_fault(regs);
304 break;
305 case HVM_GE_C_XMAL:
306 misaligned_instruction(regs);
307 break;
308 case HVM_GE_C_WREG:
309 illegal_instruction(regs);
310 break;
311 case HVM_GE_C_PCAL:
312 misaligned_instruction(regs);
313 break;
314 case HVM_GE_C_RMAL:
315 misaligned_data_load(regs);
316 break;
317 case HVM_GE_C_WMAL:
318 misaligned_data_store(regs);
319 break;
320 case HVM_GE_C_INVI:
321 case HVM_GE_C_PRIVI:
322 illegal_instruction(regs);
323 break;
324 case HVM_GE_C_BUS:
325 precise_bus_error(regs);
326 break;
327 case HVM_GE_C_CACHE:
328 cache_error(regs);
329 break;
330 default:
331 /* Halt and catch fire */
332 panic("Unrecognized exception 0x%lx\n", pt_cause(regs));
333 break;
334 }
335}
336
337void do_trap0(struct pt_regs *regs);
338void do_trap0(struct pt_regs *regs)
339{
340 syscall_fn syscall;
341
342 switch (pt_cause(regs)) {
343 case TRAP_SYSCALL:
344 /* System call is trap0 #1 */
345
346 /* allow strace to catch syscall args */
347 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) &&
348 !ptrace_report_syscall_permit_entry(regs)))
349 return; /* return -ENOSYS somewhere? */
350
351 /* Interrupts should be re-enabled for syscall processing */
352 __vmsetie(VM_INT_ENABLE);
353
354 /*
355 * System call number is in r6, arguments in r0..r5.
356 * Fortunately, no Linux syscall has more than 6 arguments,
357 * and Hexagon ABI passes first 6 arguments in registers.
358 * 64-bit arguments are passed in odd/even register pairs.
359 * Fortunately, we have no system calls that take more
360 * than three arguments with more than one 64-bit value.
361 * Should that change, we'd need to redesign to copy
362 * between user and kernel stacks.
363 */
364 regs->syscall_nr = regs->r06;
365
366 /*
367 * GPR R0 carries the first parameter, and is also used
368 * to report the return value. We need a backup of
369 * the user's value in case we need to do a late restart
370 * of the system call.
371 */
372 regs->restart_r0 = regs->r00;
373
374 if ((unsigned long) regs->syscall_nr >= __NR_syscalls) {
375 regs->r00 = -1;
376 } else {
377 syscall = (syscall_fn)
378 (sys_call_table[regs->syscall_nr]);
379 regs->r00 = syscall(regs->r00, regs->r01,
380 regs->r02, regs->r03,
381 regs->r04, regs->r05);
382 }
383
384 /* allow strace to get the syscall return state */
385 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE)))
386 ptrace_report_syscall_exit(regs, 0);
387
388 break;
389 case TRAP_DEBUG:
390 /* Trap0 0xdb is debug breakpoint */
391 if (user_mode(regs)) {
392 /*
393 * Some architecures add some per-thread state
394 * to distinguish between breakpoint traps and
395 * trace traps. We may want to do that, and
396 * set the si_code value appropriately, or we
397 * may want to use a different trap0 flavor.
398 */
399 force_sig_fault(SIGTRAP, TRAP_BRKPT,
400 (void __user *) pt_elr(regs));
401 } else {
402#ifdef CONFIG_KGDB
403 kgdb_handle_exception(pt_cause(regs), SIGTRAP,
404 TRAP_BRKPT, regs);
405#endif
406 }
407 break;
408 }
409 /* Ignore other trap0 codes for now, especially 0 (Angel calls) */
410}
411
412/*
413 * Machine check exception handler
414 */
415void do_machcheck(struct pt_regs *regs);
416void do_machcheck(struct pt_regs *regs)
417{
418 /* Halt and catch fire */
419 __vmstop();
420}
421
422/*
423 * Treat this like the old 0xdb trap.
424 */
425
426void do_debug_exception(struct pt_regs *regs);
427void do_debug_exception(struct pt_regs *regs)
428{
429 regs->hvmer.vmest &= ~HVM_VMEST_CAUSE_MSK;
430 regs->hvmer.vmest |= (TRAP_DEBUG << HVM_VMEST_CAUSE_SFT);
431 do_trap0(regs);
432}