traps.c

  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_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}