1 files changed, 315 insertions, 0 deletions
diff --git a/arch/avr32/mm/fault.c b/arch/avr32/mm/fault.c
new file mode 100644
index 000000000000..678557260a35
--- /dev/null
+++ b/arch/avr32/mm/fault.c
@@ -0,0 +1,315 @@
+/*
+ * Copyright (C) 2004-2006 Atmel Corporation
+ *
+ * Based on linux/arch/sh/mm/fault.c:
+ *   Copyright (C) 1999  Niibe Yutaka
+ *
+ * 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.
+ */
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/pagemap.h>
+#include <asm/kdebug.h>
+#include <asm/mmu_context.h>
+#include <asm/sysreg.h>
+#include <asm/uaccess.h>
+#include <asm/tlb.h>
+#ifdef DEBUG
+static void dump_code(unsigned long pc)
+{
+        char *p = (char *)pc;
+        char val;
+        int i;
+        printk(KERN_DEBUG "Code:");
+        for (i = 0; i < 16; i++) {
+                if (__get_user(val, p + i))
+                        break;
+                printk(" %02x", val);
+        }
+        printk("\n");
+}
+#endif
+#ifdef CONFIG_KPROBES
+ATOMIC_NOTIFIER_HEAD(notify_page_fault_chain);
+/* Hook to register for page fault notifications */
+int register_page_fault_notifier(struct notifier_block *nb)
+{
+        return atomic_notifier_chain_register(&notify_page_fault_chain, nb);
+}
+int unregister_page_fault_notifier(struct notifier_block *nb)
+{
+        return atomic_notifier_chain_unregister(&notify_page_fault_chain, nb);
+}
+static inline int notify_page_fault(enum die_val val, struct pt_regs *regs,
+                                    int trap, int sig)
+{
+        struct die_args args = {
+                .regs = regs,
+                .trapnr = trap,
+        };
+        return atomic_notifier_call_chain(&notify_page_fault_chain, val, &args);
+}
+#else
+static inline int notify_page_fault(enum die_val val, struct pt_regs *regs,
+                                    int trap, int sig)
+{
+        return NOTIFY_DONE;
+}
+#endif
+/*
+ * This routine handles page faults. It determines the address and the
+ * problem, and then passes it off to one of the appropriate routines.
+ *
+ * ecr is the Exception Cause Register. Possible values are:
+ *   5:  Page not found (instruction access)
+ *   6:  Protection fault (instruction access)
+ *   12: Page not found (read access)
+ *   13: Page not found (write access)
+ *   14: Protection fault (read access)
+ *   15: Protection fault (write access)
+ */
+asmlinkage void do_page_fault(unsigned long ecr, struct pt_regs *regs)
+{
+        struct task_struct *tsk;
+        struct mm_struct *mm;
+        struct vm_area_struct *vma;
+        const struct exception_table_entry *fixup;
+        unsigned long address;
+        unsigned long page;
+        int writeaccess = 0;
+        if (notify_page_fault(DIE_PAGE_FAULT, regs,
+                              ecr, SIGSEGV) == NOTIFY_STOP)
+                return;
+        address = sysreg_read(TLBEAR);
+        tsk = current;
+        mm = tsk->mm;
+        /*
+         * If we're in an interrupt or have no user context, we must
+         * not take the fault...
+         */
+        if (in_atomic() || !mm || regs->sr & SYSREG_BIT(GM))
+                goto no_context;
+        local_irq_enable();
+        down_read(&mm->mmap_sem);
+        vma = find_vma(mm, address);
+        if (!vma)
+                goto bad_area;
+        if (vma->vm_start <= address)
+                goto good_area;
+        if (!(vma->vm_flags & VM_GROWSDOWN))
+                goto bad_area;
+        if (expand_stack(vma, address))
+                goto bad_area;
+        /*
+         * Ok, we have a good vm_area for this memory access, so we
+         * can handle it...
+         */
+good_area:
+        //pr_debug("good area: vm_flags = 0x%lx\n", vma->vm_flags);
+        switch (ecr) {
+        case ECR_PROTECTION_X:
+        case ECR_TLB_MISS_X:
+                if (!(vma->vm_flags & VM_EXEC))
+                        goto bad_area;
+                break;
+        case ECR_PROTECTION_R:
+        case ECR_TLB_MISS_R:
+                if (!(vma->vm_flags & (VM_READ | VM_WRITE | VM_EXEC)))
+                        goto bad_area;
+                break;
+        case ECR_PROTECTION_W:
+        case ECR_TLB_MISS_W:
+                if (!(vma->vm_flags & VM_WRITE))
+                        goto bad_area;
+                writeaccess = 1;
+                break;
+        default:
+                panic("Unhandled case %lu in do_page_fault!", ecr);
+        }
+        /*
+         * If for any reason at all we couldn't handle the fault, make
+         * sure we exit gracefully rather than endlessly redo the
+         * fault.
+         */
+survive:
+        switch (handle_mm_fault(mm, vma, address, writeaccess)) {
+        case VM_FAULT_MINOR:
+                tsk->min_flt++;
+                break;
+        case VM_FAULT_MAJOR:
+                tsk->maj_flt++;
+                break;
+        case VM_FAULT_SIGBUS:
+                goto do_sigbus;
+        case VM_FAULT_OOM:
+                goto out_of_memory;
+        default:
+                BUG();
+        }
+        up_read(&mm->mmap_sem);
+        return;
+        /*
+         * Something tried to access memory that isn't in our memory
+         * map. Fix it, but check if it's kernel or user first...
+         */
+bad_area:
+        pr_debug("Bad area [%s:%u]: addr %08lx, ecr %lu\n",
+                 tsk->comm, tsk->pid, address, ecr);
+        up_read(&mm->mmap_sem);
+        if (user_mode(regs)) {
+                /* Hmm...we have to pass address and ecr somehow... */
+                /* tsk->thread.address = address;
+                   tsk->thread.error_code = ecr; */
+#ifdef DEBUG
+                show_regs(regs);
+                dump_code(regs->pc);
+                page = sysreg_read(PTBR);
+                printk("ptbr = %08lx", page);
+                if (page) {
+                        page = ((unsigned long *)page)[address >> 22];
+                        printk(" pgd = %08lx", page);
+                        if (page & _PAGE_PRESENT) {
+                                page &= PAGE_MASK;
+                                address &= 0x003ff000;
+                                page = ((unsigned long *)__va(page))[address >> PAGE_SHIFT];
+                                printk(" pte = %08lx\n", page);
+                        }
+                }
+#endif
+                pr_debug("Sending SIGSEGV to PID %d...\n",
+                        tsk->pid);
+                force_sig(SIGSEGV, tsk);
+                return;
+        }
+no_context:
+        pr_debug("No context\n");
+        /* Are we prepared to handle this kernel fault? */
+        fixup = search_exception_tables(regs->pc);
+        if (fixup) {
+                regs->pc = fixup->fixup;
+                pr_debug("Found fixup at %08lx\n", fixup->fixup);
+                return;
+        }
+        /*
+         * Oops. The kernel tried to access some bad page. We'll have
+         * to terminate things with extreme prejudice.
+         */
+        if (address < PAGE_SIZE)
+                printk(KERN_ALERT
+                       "Unable to handle kernel NULL pointer dereference");
+        else
+                printk(KERN_ALERT
+                       "Unable to handle kernel paging request");
+        printk(" at virtual address %08lx\n", address);
+        printk(KERN_ALERT "pc = %08lx\n", regs->pc);
+        page = sysreg_read(PTBR);
+        printk(KERN_ALERT "ptbr = %08lx", page);
+        if (page) {
+                page = ((unsigned long *)page)[address >> 22];
+                printk(" pgd = %08lx", page);
+                if (page & _PAGE_PRESENT) {
+                        page &= PAGE_MASK;
+                        address &= 0x003ff000;
+                        page = ((unsigned long *)__va(page))[address >> PAGE_SHIFT];
+                        printk(" pte = %08lx\n", page);
+                }
+        }
+        die("\nOops", regs, ecr);
+        do_exit(SIGKILL);
+        /*
+         * We ran out of memory, or some other thing happened to us
+         * that made us unable to handle the page fault gracefully.
+         */
+out_of_memory:
+        printk("Out of memory\n");
+        up_read(&mm->mmap_sem);
+        if (current->pid == 1) {
+                yield();
+                down_read(&mm->mmap_sem);
+                goto survive;
+        }
+        printk("VM: Killing process %s\n", tsk->comm);
+        if (user_mode(regs))
+                do_exit(SIGKILL);
+        goto no_context;
+do_sigbus:
+        up_read(&mm->mmap_sem);
+        /*
+         * Send a sigbus, regardless of whether we were in kernel or
+         * user mode.
+         */
+        /* address, error_code, trap_no, ... */
+#ifdef DEBUG
+        show_regs(regs);
+        dump_code(regs->pc);
+#endif
+        pr_debug("Sending SIGBUS to PID %d...\n", tsk->pid);
+        force_sig(SIGBUS, tsk);
+        /* Kernel mode? Handle exceptions or die */
+        if (!user_mode(regs))
+                goto no_context;
+}
+asmlinkage void do_bus_error(unsigned long addr, int write_access,
+                             struct pt_regs *regs)
+{
+        printk(KERN_ALERT
+               "Bus error at physical address 0x%08lx (%s access)\n",
+               addr, write_access ? "write" : "read");
+        printk(KERN_INFO "DTLB dump:\n");
+        dump_dtlb();
+        die("Bus Error", regs, write_access);
+        do_exit(SIGKILL);
+}
+/*
+ * This functionality is currently not possible to implement because
+ * we're using segmentation to ensure a fixed mapping of the kernel
+ * virtual address space.
+ *
+ * It would be possible to implement this, but it would require us to
+ * disable segmentation at startup and load the kernel mappings into
+ * the TLB like any other pages. There will be lots of trickery to
+ * avoid recursive invocation of the TLB miss handler, though...
+ */
+#ifdef CONFIG_DEBUG_PAGEALLOC
+void kernel_map_pages(struct page *page, int numpages, int enable)
+{
+}
+EXPORT_SYMBOL(kernel_map_pages);
+#endif

diff --git a/arch/avr32/mm/fault.c b/arch/avr32/mm/fault.c new file mode 100644 index 000000000000..678557260a35 --- /dev/null +++ b/arch/avr32/mm/fault.c
@@ -0,0 +1,315 @@
	1	/*
	2	* Copyright (C) 2004-2006 Atmel Corporation
	3	*
	4	* Based on linux/arch/sh/mm/fault.c:
	5	* Copyright (C) 1999 Niibe Yutaka
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <linux/mm.h>
	13	#include <linux/module.h>
	14	#include <linux/pagemap.h>
	15
	16	#include <asm/kdebug.h>
	17	#include <asm/mmu_context.h>
	18	#include <asm/sysreg.h>
	19	#include <asm/uaccess.h>
	20	#include <asm/tlb.h>
	21
	22	#ifdef DEBUG
	23	static void dump_code(unsigned long pc)
	24	{
	25	char p = (char )pc;
	26	char val;
	27	int i;
	28
	29
	30	printk(KERN_DEBUG "Code:");
	31	for (i = 0; i < 16; i++) {
	32	if (__get_user(val, p + i))
	33	break;
	34	printk(" %02x", val);
	35	}
	36	printk("\n");
	37	}
	38	#endif
	39
	40	#ifdef CONFIG_KPROBES
	41	ATOMIC_NOTIFIER_HEAD(notify_page_fault_chain);
	42
	43	/* Hook to register for page fault notifications */
	44	int register_page_fault_notifier(struct notifier_block *nb)
	45	{
	46	return atomic_notifier_chain_register(&notify_page_fault_chain, nb);
	47	}
	48
	49	int unregister_page_fault_notifier(struct notifier_block *nb)
	50	{
	51	return atomic_notifier_chain_unregister(&notify_page_fault_chain, nb);
	52	}
	53
	54	static inline int notify_page_fault(enum die_val val, struct pt_regs *regs,
	55	int trap, int sig)
	56	{
	57	struct die_args args = {
	58	.regs = regs,
	59	.trapnr = trap,
	60	};
	61	return atomic_notifier_call_chain(&notify_page_fault_chain, val, &args);
	62	}
	63	#else
	64	static inline int notify_page_fault(enum die_val val, struct pt_regs *regs,
	65	int trap, int sig)
	66	{
	67	return NOTIFY_DONE;
	68	}
	69	#endif
	70
	71	/*
	72	* This routine handles page faults. It determines the address and the
	73	* problem, and then passes it off to one of the appropriate routines.
	74	*
	75	* ecr is the Exception Cause Register. Possible values are:
	76	* 5: Page not found (instruction access)
	77	* 6: Protection fault (instruction access)
	78	* 12: Page not found (read access)
	79	* 13: Page not found (write access)
	80	* 14: Protection fault (read access)
	81	* 15: Protection fault (write access)
	82	*/
	83	asmlinkage void do_page_fault(unsigned long ecr, struct pt_regs *regs)
	84	{
	85	struct task_struct *tsk;
	86	struct mm_struct *mm;
	87	struct vm_area_struct *vma;
	88	const struct exception_table_entry *fixup;
	89	unsigned long address;
	90	unsigned long page;
	91	int writeaccess = 0;
	92
	93	if (notify_page_fault(DIE_PAGE_FAULT, regs,
	94	ecr, SIGSEGV) == NOTIFY_STOP)
	95	return;
	96
	97	address = sysreg_read(TLBEAR);
	98
	99	tsk = current;
	100	mm = tsk->mm;
	101
	102	/*
	103	* If we're in an interrupt or have no user context, we must
	104	* not take the fault...
	105	*/
	106	if (in_atomic() \|\| !mm \|\| regs->sr & SYSREG_BIT(GM))
	107	goto no_context;
	108
	109	local_irq_enable();
	110
	111	down_read(&mm->mmap_sem);
	112
	113	vma = find_vma(mm, address);
	114	if (!vma)
	115	goto bad_area;
	116	if (vma->vm_start <= address)
	117	goto good_area;
	118	if (!(vma->vm_flags & VM_GROWSDOWN))
	119	goto bad_area;
	120	if (expand_stack(vma, address))
	121	goto bad_area;
	122
	123	/*
	124	* Ok, we have a good vm_area for this memory access, so we
	125	* can handle it...
	126	*/
	127	good_area:
	128	//pr_debug("good area: vm_flags = 0x%lx\n", vma->vm_flags);
	129	switch (ecr) {
	130	case ECR_PROTECTION_X:
	131	case ECR_TLB_MISS_X:
	132	if (!(vma->vm_flags & VM_EXEC))
	133	goto bad_area;
	134	break;
	135	case ECR_PROTECTION_R:
	136	case ECR_TLB_MISS_R:
	137	if (!(vma->vm_flags & (VM_READ \| VM_WRITE \| VM_EXEC)))
	138	goto bad_area;
	139	break;
	140	case ECR_PROTECTION_W:
	141	case ECR_TLB_MISS_W:
	142	if (!(vma->vm_flags & VM_WRITE))
	143	goto bad_area;
	144	writeaccess = 1;
	145	break;
	146	default:
	147	panic("Unhandled case %lu in do_page_fault!", ecr);
	148	}
	149
	150	/*
	151	* If for any reason at all we couldn't handle the fault, make
	152	* sure we exit gracefully rather than endlessly redo the
	153	* fault.
	154	*/
	155	survive:
	156	switch (handle_mm_fault(mm, vma, address, writeaccess)) {
	157	case VM_FAULT_MINOR:
	158	tsk->min_flt++;
	159	break;
	160	case VM_FAULT_MAJOR:
	161	tsk->maj_flt++;
	162	break;
	163	case VM_FAULT_SIGBUS:
	164	goto do_sigbus;
	165	case VM_FAULT_OOM:
	166	goto out_of_memory;
	167	default:
	168	BUG();
	169	}
	170
	171	up_read(&mm->mmap_sem);
	172	return;
	173
	174	/*
	175	* Something tried to access memory that isn't in our memory
	176	* map. Fix it, but check if it's kernel or user first...
	177	*/
	178	bad_area:
	179	pr_debug("Bad area [%s:%u]: addr %08lx, ecr %lu\n",
	180	tsk->comm, tsk->pid, address, ecr);
	181
	182	up_read(&mm->mmap_sem);
	183
	184	if (user_mode(regs)) {
	185	/* Hmm...we have to pass address and ecr somehow... */
	186	/* tsk->thread.address = address;
	187	tsk->thread.error_code = ecr; */
	188	#ifdef DEBUG
	189	show_regs(regs);
	190	dump_code(regs->pc);
	191
	192	page = sysreg_read(PTBR);
	193	printk("ptbr = %08lx", page);
	194	if (page) {
	195	page = ((unsigned long *)page)[address >> 22];
	196	printk(" pgd = %08lx", page);
	197	if (page & _PAGE_PRESENT) {
	198	page &= PAGE_MASK;
	199	address &= 0x003ff000;
	200	page = ((unsigned long *)__va(page))[address >> PAGE_SHIFT];
	201	printk(" pte = %08lx\n", page);
	202	}
	203	}
	204	#endif
	205	pr_debug("Sending SIGSEGV to PID %d...\n",
	206	tsk->pid);
	207	force_sig(SIGSEGV, tsk);
	208	return;
	209	}
	210
	211	no_context:
	212	pr_debug("No context\n");
	213
	214	/* Are we prepared to handle this kernel fault? */
	215	fixup = search_exception_tables(regs->pc);
	216	if (fixup) {
	217	regs->pc = fixup->fixup;
	218	pr_debug("Found fixup at %08lx\n", fixup->fixup);
	219	return;
	220	}
	221
	222	/*
	223	* Oops. The kernel tried to access some bad page. We'll have
	224	* to terminate things with extreme prejudice.
	225	*/
	226	if (address < PAGE_SIZE)
	227	printk(KERN_ALERT
	228	"Unable to handle kernel NULL pointer dereference");
	229	else
	230	printk(KERN_ALERT
	231	"Unable to handle kernel paging request");
	232	printk(" at virtual address %08lx\n", address);
	233	printk(KERN_ALERT "pc = %08lx\n", regs->pc);
	234
	235	page = sysreg_read(PTBR);
	236	printk(KERN_ALERT "ptbr = %08lx", page);
	237	if (page) {
	238	page = ((unsigned long *)page)[address >> 22];
	239	printk(" pgd = %08lx", page);
	240	if (page & _PAGE_PRESENT) {
	241	page &= PAGE_MASK;
	242	address &= 0x003ff000;
	243	page = ((unsigned long *)__va(page))[address >> PAGE_SHIFT];
	244	printk(" pte = %08lx\n", page);
	245	}
	246	}
	247	die("\nOops", regs, ecr);
	248	do_exit(SIGKILL);
	249
	250	/*
	251	* We ran out of memory, or some other thing happened to us
	252	* that made us unable to handle the page fault gracefully.
	253	*/
	254	out_of_memory:
	255	printk("Out of memory\n");
	256	up_read(&mm->mmap_sem);
	257	if (current->pid == 1) {
	258	yield();
	259	down_read(&mm->mmap_sem);
	260	goto survive;
	261	}
	262	printk("VM: Killing process %s\n", tsk->comm);
	263	if (user_mode(regs))
	264	do_exit(SIGKILL);
	265	goto no_context;
	266
	267	do_sigbus:
	268	up_read(&mm->mmap_sem);
	269
	270	/*
	271	* Send a sigbus, regardless of whether we were in kernel or
	272	* user mode.
	273	*/
	274	/* address, error_code, trap_no, ... */
	275	#ifdef DEBUG
	276	show_regs(regs);
	277	dump_code(regs->pc);
	278	#endif
	279	pr_debug("Sending SIGBUS to PID %d...\n", tsk->pid);
	280	force_sig(SIGBUS, tsk);
	281
	282	/* Kernel mode? Handle exceptions or die */
	283	if (!user_mode(regs))
	284	goto no_context;
	285	}
	286
	287	asmlinkage void do_bus_error(unsigned long addr, int write_access,
	288	struct pt_regs *regs)
	289	{
	290	printk(KERN_ALERT
	291	"Bus error at physical address 0x%08lx (%s access)\n",
	292	addr, write_access ? "write" : "read");
	293	printk(KERN_INFO "DTLB dump:\n");
	294	dump_dtlb();
	295	die("Bus Error", regs, write_access);
	296	do_exit(SIGKILL);
	297	}
	298
	299	/*
	300	* This functionality is currently not possible to implement because
	301	* we're using segmentation to ensure a fixed mapping of the kernel
	302	* virtual address space.
	303	*
	304	* It would be possible to implement this, but it would require us to
	305	* disable segmentation at startup and load the kernel mappings into
	306	* the TLB like any other pages. There will be lots of trickery to
	307	* avoid recursive invocation of the TLB miss handler, though...
	308	*/
	309	#ifdef CONFIG_DEBUG_PAGEALLOC
	310	void kernel_map_pages(struct page *page, int numpages, int enable)
	311	{
	312
	313	}
	314	EXPORT_SYMBOL(kernel_map_pages);
	315	#endif