Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/arch/arm/kernel/traps.c
4 : : *
5 : : * Copyright (C) 1995-2009 Russell King
6 : : * Fragments that appear the same as linux/arch/i386/kernel/traps.c (C) Linus Torvalds
7 : : *
8 : : * 'traps.c' handles hardware exceptions after we have saved some state in
9 : : * 'linux/arch/arm/lib/traps.S'. Mostly a debugging aid, but will probably
10 : : * kill the offending process.
11 : : */
12 : : #include <linux/signal.h>
13 : : #include <linux/personality.h>
14 : : #include <linux/kallsyms.h>
15 : : #include <linux/spinlock.h>
16 : : #include <linux/uaccess.h>
17 : : #include <linux/hardirq.h>
18 : : #include <linux/kdebug.h>
19 : : #include <linux/kprobes.h>
20 : : #include <linux/module.h>
21 : : #include <linux/kexec.h>
22 : : #include <linux/bug.h>
23 : : #include <linux/delay.h>
24 : : #include <linux/init.h>
25 : : #include <linux/sched/signal.h>
26 : : #include <linux/sched/debug.h>
27 : : #include <linux/sched/task_stack.h>
28 : : #include <linux/irq.h>
29 : :
30 : : #include <linux/atomic.h>
31 : : #include <asm/cacheflush.h>
32 : : #include <asm/exception.h>
33 : : #include <asm/unistd.h>
34 : : #include <asm/traps.h>
35 : : #include <asm/ptrace.h>
36 : : #include <asm/unwind.h>
37 : : #include <asm/tls.h>
38 : : #include <asm/system_misc.h>
39 : : #include <asm/opcodes.h>
40 : :
41 : :
42 : : static const char *handler[]= {
43 : : "prefetch abort",
44 : : "data abort",
45 : : "address exception",
46 : : "interrupt",
47 : : "undefined instruction",
48 : : };
49 : :
50 : : void *vectors_page;
51 : :
52 : : #ifdef CONFIG_DEBUG_USER
53 : : unsigned int user_debug;
54 : :
55 : : static int __init user_debug_setup(char *str)
56 : : {
57 : : get_option(&str, &user_debug);
58 : : return 1;
59 : : }
60 : : __setup("user_debug=", user_debug_setup);
61 : : #endif
62 : :
63 : : static void dump_mem(const char *, const char *, unsigned long, unsigned long);
64 : :
65 : 1 : void dump_backtrace_entry(unsigned long where, unsigned long from, unsigned long frame)
66 : : {
67 : : #ifdef CONFIG_KALLSYMS
68 : 1 : printk("[<%08lx>] (%ps) from [<%08lx>] (%pS)\n", where, (void *)where, from, (void *)from);
69 : : #else
70 : : printk("Function entered at [<%08lx>] from [<%08lx>]\n", where, from);
71 : : #endif
72 : :
73 : 1 : if (in_entry_text(from))
74 : 1 : dump_mem("", "Exception stack", frame + 4, frame + 4 + sizeof(struct pt_regs));
75 : 1 : }
76 : :
77 : 1 : void dump_backtrace_stm(u32 *stack, u32 instruction)
78 : : {
79 : : char str[80], *p;
80 : : unsigned int x;
81 : : int reg;
82 : :
83 : 1 : for (reg = 10, x = 0, p = str; reg >= 0; reg--) {
84 : 1 : if (instruction & BIT(reg)) {
85 : 1 : p += sprintf(p, " r%d:%08x", reg, *stack--);
86 : 1 : if (++x == 6) {
87 : : x = 0;
88 : : p = str;
89 : 1 : printk("%s\n", str);
90 : : }
91 : : }
92 : : }
93 : 1 : if (p != str)
94 : 1 : printk("%s\n", str);
95 : 1 : }
96 : :
97 : : #ifndef CONFIG_ARM_UNWIND
98 : : /*
99 : : * Stack pointers should always be within the kernels view of
100 : : * physical memory. If it is not there, then we can't dump
101 : : * out any information relating to the stack.
102 : : */
103 : : static int verify_stack(unsigned long sp)
104 : : {
105 : 1 : if (sp < PAGE_OFFSET ||
106 : 1 : (sp > (unsigned long)high_memory && high_memory != NULL))
107 : : return -EFAULT;
108 : :
109 : : return 0;
110 : : }
111 : : #endif
112 : :
113 : : /*
114 : : * Dump out the contents of some memory nicely...
115 : : */
116 : 1 : static void dump_mem(const char *lvl, const char *str, unsigned long bottom,
117 : : unsigned long top)
118 : : {
119 : : unsigned long first;
120 : : mm_segment_t fs;
121 : : int i;
122 : :
123 : : /*
124 : : * We need to switch to kernel mode so that we can use __get_user
125 : : * to safely read from kernel space. Note that we now dump the
126 : : * code first, just in case the backtrace kills us.
127 : : */
128 : 1 : fs = get_fs();
129 : : set_fs(KERNEL_DS);
130 : :
131 : 1 : printk("%s%s(0x%08lx to 0x%08lx)\n", lvl, str, bottom, top);
132 : :
133 : 1 : for (first = bottom & ~31; first < top; first += 32) {
134 : : unsigned long p;
135 : : char str[sizeof(" 12345678") * 8 + 1];
136 : :
137 : 1 : memset(str, ' ', sizeof(str));
138 : 1 : str[sizeof(str) - 1] = '\0';
139 : :
140 : 1 : for (p = first, i = 0; i < 8 && p < top; i++, p += 4) {
141 : 1 : if (p >= bottom && p < top) {
142 : : unsigned long val;
143 : 1 : if (__get_user(val, (unsigned long *)p) == 0)
144 : 1 : sprintf(str + i * 9, " %08lx", val);
145 : : else
146 : 0 : sprintf(str + i * 9, " ????????");
147 : : }
148 : : }
149 : 1 : printk("%s%04lx:%s\n", lvl, first & 0xffff, str);
150 : : }
151 : :
152 : : set_fs(fs);
153 : 1 : }
154 : :
155 : 0 : static void __dump_instr(const char *lvl, struct pt_regs *regs)
156 : : {
157 : 0 : unsigned long addr = instruction_pointer(regs);
158 : 0 : const int thumb = thumb_mode(regs);
159 : 0 : const int width = thumb ? 4 : 8;
160 : : char str[sizeof("00000000 ") * 5 + 2 + 1], *p = str;
161 : : int i;
162 : :
163 : : /*
164 : : * Note that we now dump the code first, just in case the backtrace
165 : : * kills us.
166 : : */
167 : :
168 : 0 : for (i = -4; i < 1 + !!thumb; i++) {
169 : : unsigned int val, bad;
170 : :
171 : 0 : if (thumb)
172 : 0 : bad = get_user(val, &((u16 *)addr)[i]);
173 : : else
174 : 0 : bad = get_user(val, &((u32 *)addr)[i]);
175 : :
176 : 0 : if (!bad)
177 : 0 : p += sprintf(p, i == 0 ? "(%0*x) " : "%0*x ",
178 : : width, val);
179 : : else {
180 : 0 : p += sprintf(p, "bad PC value");
181 : 0 : break;
182 : : }
183 : : }
184 : 0 : printk("%sCode: %s\n", lvl, str);
185 : 0 : }
186 : :
187 : 0 : static void dump_instr(const char *lvl, struct pt_regs *regs)
188 : : {
189 : : mm_segment_t fs;
190 : :
191 : 0 : if (!user_mode(regs)) {
192 : 0 : fs = get_fs();
193 : : set_fs(KERNEL_DS);
194 : 0 : __dump_instr(lvl, regs);
195 : : set_fs(fs);
196 : : } else {
197 : 0 : __dump_instr(lvl, regs);
198 : : }
199 : 0 : }
200 : :
201 : : #ifdef CONFIG_ARM_UNWIND
202 : : static inline void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk)
203 : : {
204 : : unwind_backtrace(regs, tsk);
205 : : }
206 : : #else
207 : 1 : static void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk)
208 : : {
209 : : unsigned int fp, mode;
210 : : int ok = 1;
211 : :
212 : 1 : printk("Backtrace: ");
213 : :
214 : 1 : if (!tsk)
215 : 1 : tsk = current;
216 : :
217 : 1 : if (regs) {
218 : 0 : fp = frame_pointer(regs);
219 : 0 : mode = processor_mode(regs);
220 : 1 : } else if (tsk != current) {
221 : 0 : fp = thread_saved_fp(tsk);
222 : : mode = 0x10;
223 : : } else {
224 : 1 : asm("mov %0, fp" : "=r" (fp) : : "cc");
225 : : mode = 0x10;
226 : : }
227 : :
228 : 1 : if (!fp) {
229 : 0 : pr_cont("no frame pointer");
230 : : ok = 0;
231 : 1 : } else if (verify_stack(fp)) {
232 : 0 : pr_cont("invalid frame pointer 0x%08x", fp);
233 : : ok = 0;
234 : 1 : } else if (fp < (unsigned long)end_of_stack(tsk))
235 : 0 : pr_cont("frame pointer underflow");
236 : 1 : pr_cont("\n");
237 : :
238 : 1 : if (ok)
239 : 1 : c_backtrace(fp, mode);
240 : 1 : }
241 : : #endif
242 : :
243 : 1 : void show_stack(struct task_struct *tsk, unsigned long *sp)
244 : : {
245 : 1 : dump_backtrace(NULL, tsk);
246 : 1 : barrier();
247 : 1 : }
248 : :
249 : : #ifdef CONFIG_PREEMPT
250 : : #define S_PREEMPT " PREEMPT"
251 : : #else
252 : : #define S_PREEMPT ""
253 : : #endif
254 : : #ifdef CONFIG_SMP
255 : : #define S_SMP " SMP"
256 : : #else
257 : : #define S_SMP ""
258 : : #endif
259 : : #ifdef CONFIG_THUMB2_KERNEL
260 : : #define S_ISA " THUMB2"
261 : : #else
262 : : #define S_ISA " ARM"
263 : : #endif
264 : :
265 : 0 : static int __die(const char *str, int err, struct pt_regs *regs)
266 : : {
267 : 0 : struct task_struct *tsk = current;
268 : : static int die_counter;
269 : : int ret;
270 : :
271 : 0 : pr_emerg("Internal error: %s: %x [#%d]" S_PREEMPT S_SMP S_ISA "\n",
272 : : str, err, ++die_counter);
273 : :
274 : : /* trap and error numbers are mostly meaningless on ARM */
275 : 0 : ret = notify_die(DIE_OOPS, str, regs, err, tsk->thread.trap_no, SIGSEGV);
276 : 0 : if (ret == NOTIFY_STOP)
277 : : return 1;
278 : :
279 : 0 : print_modules();
280 : 0 : __show_regs(regs);
281 : 0 : pr_emerg("Process %.*s (pid: %d, stack limit = 0x%p)\n",
282 : : TASK_COMM_LEN, tsk->comm, task_pid_nr(tsk), end_of_stack(tsk));
283 : :
284 : 0 : if (!user_mode(regs) || in_interrupt()) {
285 : 0 : dump_mem(KERN_EMERG, "Stack: ", regs->ARM_sp,
286 : 0 : THREAD_SIZE + (unsigned long)task_stack_page(tsk));
287 : 0 : dump_backtrace(regs, tsk);
288 : 0 : dump_instr(KERN_EMERG, regs);
289 : : }
290 : :
291 : : return 0;
292 : : }
293 : :
294 : : static arch_spinlock_t die_lock = __ARCH_SPIN_LOCK_UNLOCKED;
295 : : static int die_owner = -1;
296 : : static unsigned int die_nest_count;
297 : :
298 : 0 : static unsigned long oops_begin(void)
299 : : {
300 : : int cpu;
301 : : unsigned long flags;
302 : :
303 : 0 : oops_enter();
304 : :
305 : : /* racy, but better than risking deadlock. */
306 : : raw_local_irq_save(flags);
307 : 0 : cpu = smp_processor_id();
308 : 0 : if (!arch_spin_trylock(&die_lock)) {
309 : 0 : if (cpu == die_owner)
310 : : /* nested oops. should stop eventually */;
311 : : else
312 : 0 : arch_spin_lock(&die_lock);
313 : : }
314 : 0 : die_nest_count++;
315 : 0 : die_owner = cpu;
316 : : console_verbose();
317 : 0 : bust_spinlocks(1);
318 : 0 : return flags;
319 : : }
320 : :
321 : 0 : static void oops_end(unsigned long flags, struct pt_regs *regs, int signr)
322 : : {
323 : : if (regs && kexec_should_crash(current))
324 : : crash_kexec(regs);
325 : :
326 : 0 : bust_spinlocks(0);
327 : 0 : die_owner = -1;
328 : 0 : add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
329 : 0 : die_nest_count--;
330 : 0 : if (!die_nest_count)
331 : : /* Nest count reaches zero, release the lock. */
332 : : arch_spin_unlock(&die_lock);
333 : : raw_local_irq_restore(flags);
334 : 0 : oops_exit();
335 : :
336 : 0 : if (in_interrupt())
337 : 0 : panic("Fatal exception in interrupt");
338 : 0 : if (panic_on_oops)
339 : 0 : panic("Fatal exception");
340 : 0 : if (signr)
341 : 0 : do_exit(signr);
342 : 0 : }
343 : :
344 : : /*
345 : : * This function is protected against re-entrancy.
346 : : */
347 : 0 : void die(const char *str, struct pt_regs *regs, int err)
348 : : {
349 : : enum bug_trap_type bug_type = BUG_TRAP_TYPE_NONE;
350 : 0 : unsigned long flags = oops_begin();
351 : : int sig = SIGSEGV;
352 : :
353 : 0 : if (!user_mode(regs))
354 : 0 : bug_type = report_bug(regs->ARM_pc, regs);
355 : 0 : if (bug_type != BUG_TRAP_TYPE_NONE)
356 : : str = "Oops - BUG";
357 : :
358 : 0 : if (__die(str, err, regs))
359 : : sig = 0;
360 : :
361 : 0 : oops_end(flags, regs, sig);
362 : 0 : }
363 : :
364 : 0 : void arm_notify_die(const char *str, struct pt_regs *regs,
365 : : int signo, int si_code, void __user *addr,
366 : : unsigned long err, unsigned long trap)
367 : : {
368 : 0 : if (user_mode(regs)) {
369 : 0 : current->thread.error_code = err;
370 : 0 : current->thread.trap_no = trap;
371 : :
372 : 0 : force_sig_fault(signo, si_code, addr);
373 : : } else {
374 : 0 : die(str, regs, err);
375 : : }
376 : 0 : }
377 : :
378 : : #ifdef CONFIG_GENERIC_BUG
379 : :
380 : 0 : int is_valid_bugaddr(unsigned long pc)
381 : : {
382 : : #ifdef CONFIG_THUMB2_KERNEL
383 : : u16 bkpt;
384 : : u16 insn = __opcode_to_mem_thumb16(BUG_INSTR_VALUE);
385 : : #else
386 : : u32 bkpt;
387 : : u32 insn = __opcode_to_mem_arm(BUG_INSTR_VALUE);
388 : : #endif
389 : :
390 : 0 : if (probe_kernel_address((unsigned *)pc, bkpt))
391 : : return 0;
392 : :
393 : 0 : return bkpt == insn;
394 : : }
395 : :
396 : : #endif
397 : :
398 : : static LIST_HEAD(undef_hook);
399 : : static DEFINE_RAW_SPINLOCK(undef_lock);
400 : :
401 : 3 : void register_undef_hook(struct undef_hook *hook)
402 : : {
403 : : unsigned long flags;
404 : :
405 : 3 : raw_spin_lock_irqsave(&undef_lock, flags);
406 : 3 : list_add(&hook->node, &undef_hook);
407 : 3 : raw_spin_unlock_irqrestore(&undef_lock, flags);
408 : 3 : }
409 : :
410 : 3 : void unregister_undef_hook(struct undef_hook *hook)
411 : : {
412 : : unsigned long flags;
413 : :
414 : 3 : raw_spin_lock_irqsave(&undef_lock, flags);
415 : : list_del(&hook->node);
416 : 3 : raw_spin_unlock_irqrestore(&undef_lock, flags);
417 : 3 : }
418 : :
419 : : static nokprobe_inline
420 : : int call_undef_hook(struct pt_regs *regs, unsigned int instr)
421 : : {
422 : : struct undef_hook *hook;
423 : : unsigned long flags;
424 : : int (*fn)(struct pt_regs *regs, unsigned int instr) = NULL;
425 : :
426 : 0 : raw_spin_lock_irqsave(&undef_lock, flags);
427 : 0 : list_for_each_entry(hook, &undef_hook, node)
428 : 0 : if ((instr & hook->instr_mask) == hook->instr_val &&
429 : 0 : (regs->ARM_cpsr & hook->cpsr_mask) == hook->cpsr_val)
430 : 0 : fn = hook->fn;
431 : 0 : raw_spin_unlock_irqrestore(&undef_lock, flags);
432 : :
433 : 0 : return fn ? fn(regs, instr) : 1;
434 : : }
435 : :
436 : 0 : asmlinkage void do_undefinstr(struct pt_regs *regs)
437 : : {
438 : : unsigned int instr;
439 : : void __user *pc;
440 : :
441 : 0 : pc = (void __user *)instruction_pointer(regs);
442 : :
443 : 0 : if (processor_mode(regs) == SVC_MODE) {
444 : : #ifdef CONFIG_THUMB2_KERNEL
445 : : if (thumb_mode(regs)) {
446 : : instr = __mem_to_opcode_thumb16(((u16 *)pc)[0]);
447 : : if (is_wide_instruction(instr)) {
448 : : u16 inst2;
449 : : inst2 = __mem_to_opcode_thumb16(((u16 *)pc)[1]);
450 : : instr = __opcode_thumb32_compose(instr, inst2);
451 : : }
452 : : } else
453 : : #endif
454 : 0 : instr = __mem_to_opcode_arm(*(u32 *) pc);
455 : 0 : } else if (thumb_mode(regs)) {
456 : 0 : if (get_user(instr, (u16 __user *)pc))
457 : : goto die_sig;
458 : 0 : instr = __mem_to_opcode_thumb16(instr);
459 : 0 : if (is_wide_instruction(instr)) {
460 : : unsigned int instr2;
461 : 0 : if (get_user(instr2, (u16 __user *)pc+1))
462 : : goto die_sig;
463 : : instr2 = __mem_to_opcode_thumb16(instr2);
464 : 0 : instr = __opcode_thumb32_compose(instr, instr2);
465 : : }
466 : : } else {
467 : 0 : if (get_user(instr, (u32 __user *)pc))
468 : : goto die_sig;
469 : : instr = __mem_to_opcode_arm(instr);
470 : : }
471 : :
472 : 0 : if (call_undef_hook(regs, instr) == 0)
473 : 0 : return;
474 : :
475 : : die_sig:
476 : : #ifdef CONFIG_DEBUG_USER
477 : : if (user_debug & UDBG_UNDEFINED) {
478 : : pr_info("%s (%d): undefined instruction: pc=%p\n",
479 : : current->comm, task_pid_nr(current), pc);
480 : : __show_regs(regs);
481 : : dump_instr(KERN_INFO, regs);
482 : : }
483 : : #endif
484 : 0 : arm_notify_die("Oops - undefined instruction", regs,
485 : : SIGILL, ILL_ILLOPC, pc, 0, 6);
486 : : }
487 : : NOKPROBE_SYMBOL(do_undefinstr)
488 : :
489 : : /*
490 : : * Handle FIQ similarly to NMI on x86 systems.
491 : : *
492 : : * The runtime environment for NMIs is extremely restrictive
493 : : * (NMIs can pre-empt critical sections meaning almost all locking is
494 : : * forbidden) meaning this default FIQ handling must only be used in
495 : : * circumstances where non-maskability improves robustness, such as
496 : : * watchdog or debug logic.
497 : : *
498 : : * This handler is not appropriate for general purpose use in drivers
499 : : * platform code and can be overrideen using set_fiq_handler.
500 : : */
501 : 0 : asmlinkage void __exception_irq_entry handle_fiq_as_nmi(struct pt_regs *regs)
502 : : {
503 : : struct pt_regs *old_regs = set_irq_regs(regs);
504 : :
505 : 0 : nmi_enter();
506 : :
507 : : /* nop. FIQ handlers for special arch/arm features can be added here. */
508 : :
509 : 0 : nmi_exit();
510 : :
511 : : set_irq_regs(old_regs);
512 : 0 : }
513 : :
514 : : /*
515 : : * bad_mode handles the impossible case in the vectors. If you see one of
516 : : * these, then it's extremely serious, and could mean you have buggy hardware.
517 : : * It never returns, and never tries to sync. We hope that we can at least
518 : : * dump out some state information...
519 : : */
520 : 0 : asmlinkage void bad_mode(struct pt_regs *regs, int reason)
521 : : {
522 : : console_verbose();
523 : :
524 : 0 : pr_crit("Bad mode in %s handler detected\n", handler[reason]);
525 : :
526 : 0 : die("Oops - bad mode", regs, 0);
527 : 0 : local_irq_disable();
528 : 0 : panic("bad mode");
529 : : }
530 : :
531 : 0 : static int bad_syscall(int n, struct pt_regs *regs)
532 : : {
533 : 0 : if ((current->personality & PER_MASK) != PER_LINUX) {
534 : 0 : send_sig(SIGSEGV, current, 1);
535 : 0 : return regs->ARM_r0;
536 : : }
537 : :
538 : : #ifdef CONFIG_DEBUG_USER
539 : : if (user_debug & UDBG_SYSCALL) {
540 : : pr_err("[%d] %s: obsolete system call %08x.\n",
541 : : task_pid_nr(current), current->comm, n);
542 : : dump_instr(KERN_ERR, regs);
543 : : }
544 : : #endif
545 : :
546 : 0 : arm_notify_die("Oops - bad syscall", regs, SIGILL, ILL_ILLTRP,
547 : 0 : (void __user *)instruction_pointer(regs) -
548 : 0 : (thumb_mode(regs) ? 2 : 4),
549 : : n, 0);
550 : :
551 : 0 : return regs->ARM_r0;
552 : : }
553 : :
554 : : static inline int
555 : 1 : __do_cache_op(unsigned long start, unsigned long end)
556 : : {
557 : : int ret;
558 : :
559 : : do {
560 : 1 : unsigned long chunk = min(PAGE_SIZE, end - start);
561 : :
562 : 1 : if (fatal_signal_pending(current))
563 : : return 0;
564 : :
565 : 1 : ret = flush_cache_user_range(start, start + chunk);
566 : 1 : if (ret)
567 : 0 : return ret;
568 : :
569 : 1 : cond_resched();
570 : : start += chunk;
571 : 1 : } while (start < end);
572 : :
573 : : return 0;
574 : : }
575 : :
576 : : static inline int
577 : 1 : do_cache_op(unsigned long start, unsigned long end, int flags)
578 : : {
579 : 1 : if (end < start || flags)
580 : : return -EINVAL;
581 : :
582 : 1 : if (!access_ok(start, end - start))
583 : : return -EFAULT;
584 : :
585 : 1 : return __do_cache_op(start, end);
586 : : }
587 : :
588 : : /*
589 : : * Handle all unrecognised system calls.
590 : : * 0x9f0000 - 0x9fffff are some more esoteric system calls
591 : : */
592 : : #define NR(x) ((__ARM_NR_##x) - __ARM_NR_BASE)
593 : 3 : asmlinkage int arm_syscall(int no, struct pt_regs *regs)
594 : : {
595 : 3 : if ((no >> 16) != (__ARM_NR_BASE>> 16))
596 : 0 : return bad_syscall(no, regs);
597 : :
598 : 3 : switch (no & 0xffff) {
599 : : case 0: /* branch through 0 */
600 : 0 : arm_notify_die("branch through zero", regs,
601 : : SIGSEGV, SEGV_MAPERR, NULL, 0, 0);
602 : 0 : return 0;
603 : :
604 : : case NR(breakpoint): /* SWI BREAK_POINT */
605 : 0 : regs->ARM_pc -= thumb_mode(regs) ? 2 : 4;
606 : 0 : ptrace_break(regs);
607 : 0 : return regs->ARM_r0;
608 : :
609 : : /*
610 : : * Flush a region from virtual address 'r0' to virtual address 'r1'
611 : : * _exclusive_. There is no alignment requirement on either address;
612 : : * user space does not need to know the hardware cache layout.
613 : : *
614 : : * r2 contains flags. It should ALWAYS be passed as ZERO until it
615 : : * is defined to be something else. For now we ignore it, but may
616 : : * the fires of hell burn in your belly if you break this rule. ;)
617 : : *
618 : : * (at a later date, we may want to allow this call to not flush
619 : : * various aspects of the cache. Passing '0' will guarantee that
620 : : * everything necessary gets flushed to maintain consistency in
621 : : * the specified region).
622 : : */
623 : : case NR(cacheflush):
624 : 1 : return do_cache_op(regs->ARM_r0, regs->ARM_r1, regs->ARM_r2);
625 : :
626 : : case NR(usr26):
627 : 0 : if (!(elf_hwcap & HWCAP_26BIT))
628 : : break;
629 : 0 : regs->ARM_cpsr &= ~MODE32_BIT;
630 : 0 : return regs->ARM_r0;
631 : :
632 : : case NR(usr32):
633 : 0 : if (!(elf_hwcap & HWCAP_26BIT))
634 : : break;
635 : 0 : regs->ARM_cpsr |= MODE32_BIT;
636 : 0 : return regs->ARM_r0;
637 : :
638 : : case NR(set_tls):
639 : 3 : set_tls(regs->ARM_r0);
640 : 3 : return 0;
641 : :
642 : : case NR(get_tls):
643 : 0 : return current_thread_info()->tp_value[0];
644 : :
645 : : default:
646 : : /* Calls 9f00xx..9f07ff are defined to return -ENOSYS
647 : : if not implemented, rather than raising SIGILL. This
648 : : way the calling program can gracefully determine whether
649 : : a feature is supported. */
650 : 0 : if ((no & 0xffff) <= 0x7ff)
651 : : return -ENOSYS;
652 : : break;
653 : : }
654 : : #ifdef CONFIG_DEBUG_USER
655 : : /*
656 : : * experience shows that these seem to indicate that
657 : : * something catastrophic has happened
658 : : */
659 : : if (user_debug & UDBG_SYSCALL) {
660 : : pr_err("[%d] %s: arm syscall %d\n",
661 : : task_pid_nr(current), current->comm, no);
662 : : dump_instr("", regs);
663 : : if (user_mode(regs)) {
664 : : __show_regs(regs);
665 : : c_backtrace(frame_pointer(regs), processor_mode(regs));
666 : : }
667 : : }
668 : : #endif
669 : 0 : arm_notify_die("Oops - bad syscall(2)", regs, SIGILL, ILL_ILLTRP,
670 : 0 : (void __user *)instruction_pointer(regs) -
671 : 0 : (thumb_mode(regs) ? 2 : 4),
672 : : no, 0);
673 : 0 : return 0;
674 : : }
675 : :
676 : : #ifdef CONFIG_TLS_REG_EMUL
677 : :
678 : : /*
679 : : * We might be running on an ARMv6+ processor which should have the TLS
680 : : * register but for some reason we can't use it, or maybe an SMP system
681 : : * using a pre-ARMv6 processor (there are apparently a few prototypes like
682 : : * that in existence) and therefore access to that register must be
683 : : * emulated.
684 : : */
685 : :
686 : : static int get_tp_trap(struct pt_regs *regs, unsigned int instr)
687 : : {
688 : : int reg = (instr >> 12) & 15;
689 : : if (reg == 15)
690 : : return 1;
691 : : regs->uregs[reg] = current_thread_info()->tp_value[0];
692 : : regs->ARM_pc += 4;
693 : : return 0;
694 : : }
695 : :
696 : : static struct undef_hook arm_mrc_hook = {
697 : : .instr_mask = 0x0fff0fff,
698 : : .instr_val = 0x0e1d0f70,
699 : : .cpsr_mask = PSR_T_BIT,
700 : : .cpsr_val = 0,
701 : : .fn = get_tp_trap,
702 : : };
703 : :
704 : : static int __init arm_mrc_hook_init(void)
705 : : {
706 : : register_undef_hook(&arm_mrc_hook);
707 : : return 0;
708 : : }
709 : :
710 : : late_initcall(arm_mrc_hook_init);
711 : :
712 : : #endif
713 : :
714 : : /*
715 : : * A data abort trap was taken, but we did not handle the instruction.
716 : : * Try to abort the user program, or panic if it was the kernel.
717 : : */
718 : : asmlinkage void
719 : 0 : baddataabort(int code, unsigned long instr, struct pt_regs *regs)
720 : : {
721 : 0 : unsigned long addr = instruction_pointer(regs);
722 : :
723 : : #ifdef CONFIG_DEBUG_USER
724 : : if (user_debug & UDBG_BADABORT) {
725 : : pr_err("8<--- cut here ---\n");
726 : : pr_err("[%d] %s: bad data abort: code %d instr 0x%08lx\n",
727 : : task_pid_nr(current), current->comm, code, instr);
728 : : dump_instr(KERN_ERR, regs);
729 : : show_pte(KERN_ERR, current->mm, addr);
730 : : }
731 : : #endif
732 : :
733 : 0 : arm_notify_die("unknown data abort code", regs,
734 : : SIGILL, ILL_ILLOPC, (void __user *)addr, instr, 0);
735 : 0 : }
736 : :
737 : 0 : void __readwrite_bug(const char *fn)
738 : : {
739 : 0 : pr_err("%s called, but not implemented\n", fn);
740 : 0 : BUG();
741 : : }
742 : : EXPORT_SYMBOL(__readwrite_bug);
743 : :
744 : 0 : void __pte_error(const char *file, int line, pte_t pte)
745 : : {
746 : 0 : pr_err("%s:%d: bad pte %08llx.\n", file, line, (long long)pte_val(pte));
747 : 0 : }
748 : :
749 : 0 : void __pmd_error(const char *file, int line, pmd_t pmd)
750 : : {
751 : 0 : pr_err("%s:%d: bad pmd %08llx.\n", file, line, (long long)pmd_val(pmd));
752 : 0 : }
753 : :
754 : 0 : void __pgd_error(const char *file, int line, pgd_t pgd)
755 : : {
756 : 0 : pr_err("%s:%d: bad pgd %08llx.\n", file, line, (long long)pgd_val(pgd));
757 : 0 : }
758 : :
759 : 0 : asmlinkage void __div0(void)
760 : : {
761 : 0 : pr_err("Division by zero in kernel.\n");
762 : 0 : dump_stack();
763 : 0 : }
764 : : EXPORT_SYMBOL(__div0);
765 : :
766 : 0 : void abort(void)
767 : : {
768 : 0 : BUG();
769 : :
770 : : /* if that doesn't kill us, halt */
771 : : panic("Oops failed to kill thread");
772 : : }
773 : :
774 : 3 : void __init trap_init(void)
775 : : {
776 : 3 : return;
777 : : }
778 : :
779 : : #ifdef CONFIG_KUSER_HELPERS
780 : 3 : static void __init kuser_init(void *vectors)
781 : : {
782 : : extern char __kuser_helper_start[], __kuser_helper_end[];
783 : 3 : int kuser_sz = __kuser_helper_end - __kuser_helper_start;
784 : :
785 : 3 : memcpy(vectors + 0x1000 - kuser_sz, __kuser_helper_start, kuser_sz);
786 : :
787 : : /*
788 : : * vectors + 0xfe0 = __kuser_get_tls
789 : : * vectors + 0xfe8 = hardware TLS instruction at 0xffff0fe8
790 : : */
791 : : if (tls_emu || has_tls_reg)
792 : 3 : memcpy(vectors + 0xfe0, vectors + 0xfe8, 4);
793 : 3 : }
794 : : #else
795 : : static inline void __init kuser_init(void *vectors)
796 : : {
797 : : }
798 : : #endif
799 : :
800 : 3 : void __init early_trap_init(void *vectors_base)
801 : : {
802 : : #ifndef CONFIG_CPU_V7M
803 : 3 : unsigned long vectors = (unsigned long)vectors_base;
804 : : extern char __stubs_start[], __stubs_end[];
805 : : extern char __vectors_start[], __vectors_end[];
806 : : unsigned i;
807 : :
808 : 3 : vectors_page = vectors_base;
809 : :
810 : : /*
811 : : * Poison the vectors page with an undefined instruction. This
812 : : * instruction is chosen to be undefined for both ARM and Thumb
813 : : * ISAs. The Thumb version is an undefined instruction with a
814 : : * branch back to the undefined instruction.
815 : : */
816 : 3 : for (i = 0; i < PAGE_SIZE / sizeof(u32); i++)
817 : 3 : ((u32 *)vectors_base)[i] = 0xe7fddef1;
818 : :
819 : : /*
820 : : * Copy the vectors, stubs and kuser helpers (in entry-armv.S)
821 : : * into the vector page, mapped at 0xffff0000, and ensure these
822 : : * are visible to the instruction stream.
823 : : */
824 : 3 : memcpy((void *)vectors, __vectors_start, __vectors_end - __vectors_start);
825 : 3 : memcpy((void *)vectors + 0x1000, __stubs_start, __stubs_end - __stubs_start);
826 : :
827 : 3 : kuser_init(vectors_base);
828 : :
829 : 3 : flush_icache_range(vectors, vectors + PAGE_SIZE * 2);
830 : : #else /* ifndef CONFIG_CPU_V7M */
831 : : /*
832 : : * on V7-M there is no need to copy the vector table to a dedicated
833 : : * memory area. The address is configurable and so a table in the kernel
834 : : * image can be used.
835 : : */
836 : : #endif
837 : 3 : }
|
