704 lines · 17.0 KB · C
RawDownload
/* *  linux/arch/arm/kernel/traps.c * *  Copyright (C) 1995-2002 Russell King *  Fragments that appear the same as linux/arch/i386/kernel/traps.c (C) Linus Torvalds * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * *  'traps.c' handles hardware exceptions after we have saved some state in *  'linux/arch/arm/lib/traps.S'.  Mostly a debugging aid, but will probably *  kill the offending process. */#include <linux/module.h>#include <linux/signal.h>#include <linux/spinlock.h>#include <linux/personality.h>#include <linux/ptrace.h>#include <linux/kallsyms.h>#include <linux/delay.h>#include <linux/init.h> #include <asm/atomic.h>#include <asm/cacheflush.h>#include <asm/system.h>#include <asm/uaccess.h>#include <asm/unistd.h>#include <asm/traps.h>#include <asm/io.h> #include "ptrace.h"#include "signal.h" static const char *handler[]= { "prefetch abort", "data abort", "address exception", "interrupt" }; #ifdef CONFIG_DEBUG_USERunsigned int user_debug; static int __init user_debug_setup(char *str){	get_option(&str, &user_debug);	return 1;}__setup("user_debug=", user_debug_setup);#endif void dump_backtrace_entry(unsigned long where, unsigned long from){#ifdef CONFIG_KALLSYMS	printk("[<%08lx>] ", where);	print_symbol("(%s) ", where);	printk("from [<%08lx>] ", from);	print_symbol("(%s)\n", from);#else	printk("Function entered at [<%08lx>] from [<%08lx>]\n", where, from);#endif} /* * Stack pointers should always be within the kernels view of * physical memory.  If it is not there, then we can't dump * out any information relating to the stack. */static int verify_stack(unsigned long sp){	if (sp < PAGE_OFFSET || (sp > (unsigned long)high_memory && high_memory != 0))		return -EFAULT; 	return 0;} /* * Dump out the contents of some memory nicely... */static void dump_mem(const char *str, unsigned long bottom, unsigned long top){	unsigned long p = bottom & ~31;	mm_segment_t fs;	int i; 	/*	 * We need to switch to kernel mode so that we can use __get_user	 * to safely read from kernel space.  Note that we now dump the	 * code first, just in case the backtrace kills us.	 */	fs = get_fs();	set_fs(KERNEL_DS); 	printk("%s(0x%08lx to 0x%08lx)\n", str, bottom, top); 	for (p = bottom & ~31; p < top;) {		printk("%04lx: ", p & 0xffff); 		for (i = 0; i < 8; i++, p += 4) {			unsigned int val; 			if (p < bottom || p >= top)				printk("         ");			else {				__get_user(val, (unsigned long *)p);				printk("%08x ", val);			}		}		printk ("\n");	} 	set_fs(fs);} static void dump_instr(struct pt_regs *regs){	unsigned long addr = instruction_pointer(regs);	const int thumb = thumb_mode(regs);	const int width = thumb ? 4 : 8;	mm_segment_t fs;	int i; 	/*	 * We need to switch to kernel mode so that we can use __get_user	 * to safely read from kernel space.  Note that we now dump the	 * code first, just in case the backtrace kills us.	 */	fs = get_fs();	set_fs(KERNEL_DS); 	printk("Code: ");	for (i = -4; i < 1; i++) {		unsigned int val, bad; 		if (thumb)			bad = __get_user(val, &((u16 *)addr)[i]);		else			bad = __get_user(val, &((u32 *)addr)[i]); 		if (!bad)			printk(i == 0 ? "(%0*x) " : "%0*x ", width, val);		else {			printk("bad PC value.");			break;		}	}	printk("\n"); 	set_fs(fs);} static void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk){	unsigned int fp;	int ok = 1; 	printk("Backtrace: ");	fp = regs->ARM_fp;	if (!fp) {		printk("no frame pointer");		ok = 0;	} else if (verify_stack(fp)) {		printk("invalid frame pointer 0x%08x", fp);		ok = 0;	} else if (fp < (unsigned long)end_of_stack(tsk))		printk("frame pointer underflow");	printk("\n"); 	if (ok)		c_backtrace(fp, processor_mode(regs));} void dump_stack(void){#ifdef CONFIG_DEBUG_ERRORS	__backtrace();#endif} EXPORT_SYMBOL(dump_stack); void show_stack(struct task_struct *tsk, unsigned long *sp){	unsigned long fp; 	if (!tsk)		tsk = current; 	if (tsk != current)		fp = thread_saved_fp(tsk);	else		asm("mov %0, fp" : "=r" (fp) : : "cc"); 	c_backtrace(fp, 0x10);	barrier();} static void __die(const char *str, int err, struct thread_info *thread, struct pt_regs *regs){	struct task_struct *tsk = thread->task;	static int die_counter; 	printk("Internal error: %s: %x [#%d]\n", str, err, ++die_counter);	print_modules();	__show_regs(regs);	printk("Process %s (pid: %d, stack limit = 0x%p)\n",		tsk->comm, tsk->pid, thread + 1); 	if (!user_mode(regs) || in_interrupt()) {		dump_mem("Stack: ", regs->ARM_sp,			 THREAD_SIZE + (unsigned long)task_stack_page(tsk));		dump_backtrace(regs, tsk);		dump_instr(regs);	}} DEFINE_SPINLOCK(die_lock); /* * This function is protected against re-entrancy. */NORET_TYPE void die(const char *str, struct pt_regs *regs, int err){	struct thread_info *thread = current_thread_info(); 	console_verbose();	spin_lock_irq(&die_lock);	bust_spinlocks(1);	__die(str, err, thread, regs);	bust_spinlocks(0);	spin_unlock_irq(&die_lock); 	if (panic_on_oops)		panic("Fatal exception"); 	do_exit(SIGSEGV);} void notify_die(const char *str, struct pt_regs *regs, struct siginfo *info,		unsigned long err, unsigned long trap){	if (user_mode(regs)) {		current->thread.error_code = err;		current->thread.trap_no = trap; 		force_sig_info(info->si_signo, info, current);	} else {		die(str, regs, err);	}} static LIST_HEAD(undef_hook);static DEFINE_SPINLOCK(undef_lock); void register_undef_hook(struct undef_hook *hook){	unsigned long flags; 	spin_lock_irqsave(&undef_lock, flags);	list_add(&hook->node, &undef_hook);	spin_unlock_irqrestore(&undef_lock, flags);} void unregister_undef_hook(struct undef_hook *hook){	unsigned long flags; 	spin_lock_irqsave(&undef_lock, flags);	list_del(&hook->node);	spin_unlock_irqrestore(&undef_lock, flags);} asmlinkage void do_undefinstr(struct pt_regs *regs){	unsigned int correction = thumb_mode(regs) ? 2 : 4;	unsigned int instr;	struct undef_hook *hook;	siginfo_t info;	void __user *pc; 	/*	 * According to the ARM ARM, PC is 2 or 4 bytes ahead,	 * depending whether we're in Thumb mode or not.	 * Correct this offset.	 */	regs->ARM_pc -= correction; 	pc = (void __user *)instruction_pointer(regs); 	if (processor_mode(regs) == SVC_MODE) {		instr = *(u32 *) pc;	} else if (thumb_mode(regs)) {		get_user(instr, (u16 __user *)pc);	} else {		get_user(instr, (u32 __user *)pc);	} 	spin_lock_irq(&undef_lock);	list_for_each_entry(hook, &undef_hook, node) {		if ((instr & hook->instr_mask) == hook->instr_val &&		    (regs->ARM_cpsr & hook->cpsr_mask) == hook->cpsr_val) {			if (hook->fn(regs, instr) == 0) {				spin_unlock_irq(&undef_lock);				return;			}		}	}	spin_unlock_irq(&undef_lock); #ifdef CONFIG_DEBUG_USER	if (user_debug & UDBG_UNDEFINED) {		printk(KERN_INFO "%s (%d): undefined instruction: pc=%p\n",			current->comm, current->pid, pc);		dump_instr(regs);	}#endif 	info.si_signo = SIGILL;	info.si_errno = 0;	info.si_code  = ILL_ILLOPC;	info.si_addr  = pc; 	notify_die("Oops - undefined instruction", regs, &info, 0, 6);} asmlinkage void do_unexp_fiq (struct pt_regs *regs){#ifndef CONFIG_IGNORE_FIQ	printk("Hmm.  Unexpected FIQ received, but trying to continue\n");	printk("You may have a hardware problem...\n");#endif} /* * bad_mode handles the impossible case in the vectors.  If you see one of * these, then it's extremely serious, and could mean you have buggy hardware. * It never returns, and never tries to sync.  We hope that we can at least * dump out some state information... */asmlinkage void bad_mode(struct pt_regs *regs, int reason){	console_verbose(); 	printk(KERN_CRIT "Bad mode in %s handler detected\n", handler[reason]); 	die("Oops - bad mode", regs, 0);	local_irq_disable();	panic("bad mode");} static int bad_syscall(int n, struct pt_regs *regs){	struct thread_info *thread = current_thread_info();	siginfo_t info; 	if (current->personality != PER_LINUX &&	    current->personality != PER_LINUX_32BIT &&	    thread->exec_domain->handler) {		thread->exec_domain->handler(n, regs);		return regs->ARM_r0;	} #ifdef CONFIG_DEBUG_USER	if (user_debug & UDBG_SYSCALL) {		printk(KERN_ERR "[%d] %s: obsolete system call %08x.\n",			current->pid, current->comm, n);		dump_instr(regs);	}#endif 	info.si_signo = SIGILL;	info.si_errno = 0;	info.si_code  = ILL_ILLTRP;	info.si_addr  = (void __user *)instruction_pointer(regs) -			 (thumb_mode(regs) ? 2 : 4); 	notify_die("Oops - bad syscall", regs, &info, n, 0); 	return regs->ARM_r0;} static inline voiddo_cache_op(unsigned long start, unsigned long end, int flags){	struct vm_area_struct *vma; 	if (end < start || flags)		return; 	vma = find_vma(current->active_mm, start);	if (vma && vma->vm_start < end) {		if (start < vma->vm_start)			start = vma->vm_start;		if (end > vma->vm_end)			end = vma->vm_end; 		flush_cache_user_range(vma, start, end);	}} /* * Handle all unrecognised system calls. *  0x9f0000 - 0x9fffff are some more esoteric system calls */#define NR(x) ((__ARM_NR_##x) - __ARM_NR_BASE)asmlinkage int arm_syscall(int no, struct pt_regs *regs){	struct thread_info *thread = current_thread_info();	siginfo_t info; 	if ((no >> 16) != (__ARM_NR_BASE>> 16))		return bad_syscall(no, regs); 	switch (no & 0xffff) {	case 0: /* branch through 0 */		info.si_signo = SIGSEGV;		info.si_errno = 0;		info.si_code  = SEGV_MAPERR;		info.si_addr  = NULL; 		notify_die("branch through zero", regs, &info, 0, 0);		return 0; 	case NR(breakpoint): /* SWI BREAK_POINT */		regs->ARM_pc -= thumb_mode(regs) ? 2 : 4;		ptrace_break(current, regs);		return regs->ARM_r0; 	/*	 * Flush a region from virtual address 'r0' to virtual address 'r1'	 * _exclusive_.  There is no alignment requirement on either address;	 * user space does not need to know the hardware cache layout.	 *	 * r2 contains flags.  It should ALWAYS be passed as ZERO until it	 * is defined to be something else.  For now we ignore it, but may	 * the fires of hell burn in your belly if you break this rule. ;)	 *	 * (at a later date, we may want to allow this call to not flush	 * various aspects of the cache.  Passing '0' will guarantee that	 * everything necessary gets flushed to maintain consistency in	 * the specified region).	 */	case NR(cacheflush):		do_cache_op(regs->ARM_r0, regs->ARM_r1, regs->ARM_r2);		return 0; 	case NR(usr26):		if (!(elf_hwcap & HWCAP_26BIT))			break;		regs->ARM_cpsr &= ~MODE32_BIT;		return regs->ARM_r0; 	case NR(usr32):		if (!(elf_hwcap & HWCAP_26BIT))			break;		regs->ARM_cpsr |= MODE32_BIT;		return regs->ARM_r0; 	case NR(set_tls):		thread->tp_value = regs->ARM_r0;#if defined(CONFIG_HAS_TLS_REG)		asm ("mcr p15, 0, %0, c13, c0, 3" : : "r" (regs->ARM_r0) );#elif !defined(CONFIG_TLS_REG_EMUL)		/*		 * User space must never try to access this directly.		 * Expect your app to break eventually if you do so.		 * The user helper at 0xffff0fe0 must be used instead.		 * (see entry-armv.S for details)		 */		*((unsigned int *)0xffff0ff0) = regs->ARM_r0;#endif		return 0; #ifdef CONFIG_NEEDS_SYSCALL_FOR_CMPXCHG	/*	 * Atomically store r1 in *r2 if *r2 is equal to r0 for user space.	 * Return zero in r0 if *MEM was changed or non-zero if no exchange	 * happened.  Also set the user C flag accordingly.	 * If access permissions have to be fixed up then non-zero is	 * returned and the operation has to be re-attempted.	 *	 * *NOTE*: This is a ghost syscall private to the kernel.  Only the	 * __kuser_cmpxchg code in entry-armv.S should be aware of its	 * existence.  Don't ever use this from user code.	 */	case 0xfff0:	{		extern void do_DataAbort(unsigned long addr, unsigned int fsr,					 struct pt_regs *regs);		unsigned long val;		unsigned long addr = regs->ARM_r2;		struct mm_struct *mm = current->mm;		pgd_t *pgd; pmd_t *pmd; pte_t *pte;		spinlock_t *ptl; 		regs->ARM_cpsr &= ~PSR_C_BIT;		down_read(&mm->mmap_sem);		pgd = pgd_offset(mm, addr);		if (!pgd_present(*pgd))			goto bad_access;		pmd = pmd_offset(pgd, addr);		if (!pmd_present(*pmd))			goto bad_access;		pte = pte_offset_map_lock(mm, pmd, addr, &ptl);

Lines 1–500 of 704.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t