[linux-2.6-block.git] / arch / sh / mm / fault_32.c

/*
 * Page fault handler for SH with an MMU.
 *
 *  Copyright (C) 1999  Niibe Yutaka
 *  Copyright (C) 2003 - 2008  Paul Mundt
 *
 *  Based on linux/arch/i386/mm/fault.c:
 *   Copyright (C) 1995  Linus Torvalds
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/hardirq.h>
#include <linux/kprobes.h>
#include <linux/marker.h>
#include <asm/io_trapped.h>
#include <asm/system.h>
#include <asm/mmu_context.h>
#include <asm/tlbflush.h>

/*
 * This routine handles page faults.  It determines the address,
 * and the problem, and then passes it off to one of the appropriate
 * routines.
 */
asmlinkage void __kprobes do_page_fault(struct pt_regs *regs,
					unsigned long writeaccess,
					unsigned long address)
{
	struct task_struct *tsk;
	struct mm_struct *mm;
	struct vm_area_struct * vma;
	int si_code;
	int fault;
	siginfo_t info;

	/*
	 * We don't bother with any notifier callbacks here, as they are
	 * all handled through the __do_page_fault() fast-path.
	 */

	tsk = current;
	si_code = SEGV_MAPERR;

	if (unlikely(address >= TASK_SIZE)) {
		/*
		 * Synchronize this task's top level page-table
		 * with the 'reference' page table.
		 *
		 * Do _not_ use "tsk" here. We might be inside
		 * an interrupt in the middle of a task switch..
		 */
		int offset = pgd_index(address);
		pgd_t *pgd, *pgd_k;
		pud_t *pud, *pud_k;
		pmd_t *pmd, *pmd_k;

		pgd = get_TTB() + offset;
		pgd_k = swapper_pg_dir + offset;

		if (!pgd_present(*pgd)) {
			if (!pgd_present(*pgd_k))
				goto bad_area_nosemaphore;
			set_pgd(pgd, *pgd_k);
			return;
		}

		pud = pud_offset(pgd, address);
		pud_k = pud_offset(pgd_k, address);

		if (!pud_present(*pud)) {
			if (!pud_present(*pud_k))
				goto bad_area_nosemaphore;
			set_pud(pud, *pud_k);
			return;
		}

		pmd = pmd_offset(pud, address);
		pmd_k = pmd_offset(pud_k, address);
		if (pmd_present(*pmd) || !pmd_present(*pmd_k))
			goto bad_area_nosemaphore;
		set_pmd(pmd, *pmd_k);

		return;
	}

	/* Only enable interrupts if they were on before the fault */
	if ((regs->sr & SR_IMASK) != SR_IMASK) {
		trace_hardirqs_on();
		local_irq_enable();
	}

	mm = tsk->mm;

	/*
	 * If we're in an interrupt or have no user
	 * context, we must not take the fault..
	 */
	if (in_atomic() || !mm)
		goto no_context;

	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:
	si_code = SEGV_ACCERR;
	if (writeaccess) {
		if (!(vma->vm_flags & VM_WRITE))
			goto bad_area;
	} else {
		if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
			goto bad_area;
	}

	/*
	 * If for any reason at all we couldn't handle the fault,
	 * make sure we exit gracefully rather than endlessly redo
	 * the fault.
	 */
survive:
	fault = handle_mm_fault(mm, vma, address, writeaccess ? FAULT_FLAG_WRITE : 0);
	if (unlikely(fault & VM_FAULT_ERROR)) {
		if (fault & VM_FAULT_OOM)
			goto out_of_memory;
		else if (fault & VM_FAULT_SIGBUS)
			goto do_sigbus;
		BUG();
	}
	if (fault & VM_FAULT_MAJOR)
		tsk->maj_flt++;
	else
		tsk->min_flt++;

	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:
	up_read(&mm->mmap_sem);

bad_area_nosemaphore:
	if (user_mode(regs)) {
		info.si_signo = SIGSEGV;
		info.si_errno = 0;
		info.si_code = si_code;
		info.si_addr = (void *) address;
		force_sig_info(SIGSEGV, &info, tsk);
		return;
	}

no_context:
	/* Are we prepared to handle this kernel fault?  */
	if (fixup_exception(regs))
		return;

	if (handle_trapped_io(regs, address))
		return;
/*
 * Oops. The kernel tried to access some bad page. We'll have to
 * terminate things with extreme prejudice.
 *
 */

	bust_spinlocks(1);

	if (oops_may_print()) {
		unsigned long page;

		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 = (unsigned long)get_TTB();
		if (page) {
			page = ((__typeof__(page) *)page)[address >> PGDIR_SHIFT];
			printk(KERN_ALERT "*pde = %08lx\n", page);
			if (page & _PAGE_PRESENT) {
				page &= PAGE_MASK;
				address &= 0x003ff000;
				page = ((__typeof__(page) *)
						__va(page))[address >>
							    PAGE_SHIFT];
				printk(KERN_ALERT "*pte = %08lx\n", page);
			}
		}
	}

	die("Oops", regs, writeaccess);
	bust_spinlocks(0);
	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:
	up_read(&mm->mmap_sem);
	if (is_global_init(current)) {
		yield();
		down_read(&mm->mmap_sem);
		goto survive;
	}
	printk("VM: killing process %s\n", tsk->comm);
	if (user_mode(regs))
		do_group_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.
	 */
	info.si_signo = SIGBUS;
	info.si_errno = 0;
	info.si_code = BUS_ADRERR;
	info.si_addr = (void *)address;
	force_sig_info(SIGBUS, &info, tsk);

	/* Kernel mode? Handle exceptions or die */
	if (!user_mode(regs))
		goto no_context;
}

static inline int notify_page_fault(struct pt_regs *regs, int trap)
{
	int ret = 0;

#ifdef CONFIG_KPROBES
	if (!user_mode(regs)) {
		preempt_disable();
		if (kprobe_running() && kprobe_fault_handler(regs, trap))
			ret = 1;
		preempt_enable();
	}
#endif

	return ret;
}

/*
 * Called with interrupts disabled.
 */
asmlinkage int __kprobes __do_page_fault(struct pt_regs *regs,
					 unsigned long writeaccess,
					 unsigned long address)
{
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd;
	pte_t *pte;
	pte_t entry;
	int ret = 0;

	if (notify_page_fault(regs, lookup_exception_vector()))
		goto out;

	ret = 1;

	/*
	 * We don't take page faults for P1, P2, and parts of P4, these
	 * are always mapped, whether it be due to legacy behaviour in
	 * 29-bit mode, or due to PMB configuration in 32-bit mode.
	 */
	if (address >= P3SEG && address < P3_ADDR_MAX) {
		pgd = pgd_offset_k(address);
	} else {
		if (unlikely(address >= TASK_SIZE || !current->mm))
			goto out;

		pgd = pgd_offset(current->mm, address);
	}

	pud = pud_offset(pgd, address);
	if (pud_none_or_clear_bad(pud))
		goto out;
	pmd = pmd_offset(pud, address);
	if (pmd_none_or_clear_bad(pmd))
		goto out;
	pte = pte_offset_kernel(pmd, address);
	entry = *pte;
	if (unlikely(pte_none(entry) || pte_not_present(entry)))
		goto out;
	if (unlikely(writeaccess && !pte_write(entry)))
		goto out;

	if (writeaccess)
		entry = pte_mkdirty(entry);
	entry = pte_mkyoung(entry);

#if defined(CONFIG_CPU_SH4) && !defined(CONFIG_SMP)
	/*
	 * ITLB is not affected by "ldtlb" instruction.
	 * So, we need to flush the entry by ourselves.
	 */
	local_flush_tlb_one(get_asid(), address & PAGE_MASK);
#endif

	set_pte(pte, entry);
	update_mmu_cache(NULL, address, entry);

	ret = 0;
out:
	return ret;
}
Commit	Line	Data
26ff6c11 PM	1	/*
26ff6c11 PM	2	* Page fault handler for SH with an MMU.
1da177e4	3	*
1da177e4	4	* Copyright (C) 1999 Niibe Yutaka
037c10a6	5	* Copyright (C) 2003 - 2008 Paul Mundt
1da177e4 LT	6	*
	7	* Based on linux/arch/i386/mm/fault.c:
	8	* Copyright (C) 1995 Linus Torvalds
26ff6c11 PM	9	*
	10	* This file is subject to the terms and conditions of the GNU General Public
	11	* License. See the file "COPYING" in the main directory of this archive
	12	* for more details.
1da177e4	13	*/
1da177e4	14	#include <linux/kernel.h>
1da177e4	15	#include <linux/mm.h>
0f08f338 PM	16	#include <linux/hardirq.h>
0f08f338 PM	17	#include <linux/kprobes.h>
3d58695e	18	#include <linux/marker.h>
e7cc9a73	19	#include <asm/io_trapped.h>
1da177e4	20	#include <asm/system.h>
1da177e4	21	#include <asm/mmu_context.h>
db2e1fa3	22	#include <asm/tlbflush.h>
1da177e4	23
1da177e4 LT	24	/*
	25	* This routine handles page faults. It determines the address,
	26	* and the problem, and then passes it off to one of the appropriate
	27	* routines.
	28	*/
b5a1bcbe SM	29	asmlinkage void __kprobes do_page_fault(struct pt_regs *regs,
	30	unsigned long writeaccess,
	31	unsigned long address)
1da177e4 LT	32	{
	33	struct task_struct *tsk;
	34	struct mm_struct *mm;
	35	struct vm_area_struct * vma;
b5a1bcbe	36	int si_code;
83c54070	37	int fault;
b5a1bcbe	38	siginfo_t info;
1da177e4	39
8f2baee2 PM	40	/*
	41	* We don't bother with any notifier callbacks here, as they are
	42	* all handled through the __do_page_fault() fast-path.
	43	*/
1da177e4 LT	44
1da177e4 LT	45	tsk = current;
b5a1bcbe	46	si_code = SEGV_MAPERR;
1da177e4	47
99a596f9 SM	48	if (unlikely(address >= TASK_SIZE)) {
	49	/*
	50	* Synchronize this task's top level page-table
	51	* with the 'reference' page table.
	52	*
	53	* Do _not_ use "tsk" here. We might be inside
	54	* an interrupt in the middle of a task switch..
	55	*/
	56	int offset = pgd_index(address);
	57	pgd_t pgd, pgd_k;
	58	pud_t pud, pud_k;
	59	pmd_t pmd, pmd_k;
	60
	61	pgd = get_TTB() + offset;
	62	pgd_k = swapper_pg_dir + offset;
	63
99a596f9 SM	64	if (!pgd_present(*pgd)) {
	65	if (!pgd_present(*pgd_k))
	66	goto bad_area_nosemaphore;
	67	set_pgd(pgd, *pgd_k);
	68	return;
	69	}
	70
	71	pud = pud_offset(pgd, address);
	72	pud_k = pud_offset(pgd_k, address);
96e14e54 SM	73
	74	if (!pud_present(*pud)) {
	75	if (!pud_present(*pud_k))
	76	goto bad_area_nosemaphore;
	77	set_pud(pud, *pud_k);
	78	return;
	79	}
99a596f9 SM	80
	81	pmd = pmd_offset(pud, address);
	82	pmd_k = pmd_offset(pud_k, address);
	83	if (pmd_present(pmd) \|\| !pmd_present(pmd_k))
	84	goto bad_area_nosemaphore;
	85	set_pmd(pmd, *pmd_k);
	86
	87	return;
	88	}
	89
f2fb4e4f SM	90	/* Only enable interrupts if they were on before the fault */
	91	if ((regs->sr & SR_IMASK) != SR_IMASK) {
	92	trace_hardirqs_on();
	93	local_irq_enable();
	94	}
	95
	96	mm = tsk->mm;
	97
1da177e4 LT	98	/*
	99	* If we're in an interrupt or have no user
	100	* context, we must not take the fault..
	101	*/
	102	if (in_atomic() \|\| !mm)
	103	goto no_context;
	104
	105	down_read(&mm->mmap_sem);
	106
	107	vma = find_vma(mm, address);
	108	if (!vma)
	109	goto bad_area;
	110	if (vma->vm_start <= address)
	111	goto good_area;
	112	if (!(vma->vm_flags & VM_GROWSDOWN))
	113	goto bad_area;
	114	if (expand_stack(vma, address))
	115	goto bad_area;
	116	/*
	117	* Ok, we have a good vm_area for this memory access, so
	118	* we can handle it..
	119	*/
	120	good_area:
b5a1bcbe	121	si_code = SEGV_ACCERR;
1da177e4 LT	122	if (writeaccess) {
	123	if (!(vma->vm_flags & VM_WRITE))
	124	goto bad_area;
	125	} else {
df67b3da	126	if (!(vma->vm_flags & (VM_READ \| VM_EXEC \| VM_WRITE)))
1da177e4 LT	127	goto bad_area;
	128	}
	129
	130	/*
	131	* If for any reason at all we couldn't handle the fault,
	132	* make sure we exit gracefully rather than endlessly redo
	133	* the fault.
	134	*/
	135	survive:
d06063cc	136	fault = handle_mm_fault(mm, vma, address, writeaccess ? FAULT_FLAG_WRITE : 0);
83c54070 NP	137	if (unlikely(fault & VM_FAULT_ERROR)) {
83c54070 NP	138	if (fault & VM_FAULT_OOM)
1da177e4	139	goto out_of_memory;
83c54070 NP	140	else if (fault & VM_FAULT_SIGBUS)
	141	goto do_sigbus;
	142	BUG();
1da177e4	143	}
83c54070 NP	144	if (fault & VM_FAULT_MAJOR)
	145	tsk->maj_flt++;
	146	else
	147	tsk->min_flt++;
1da177e4 LT	148
	149	up_read(&mm->mmap_sem);
	150	return;
	151
	152	/*
	153	* Something tried to access memory that isn't in our memory map..
	154	* Fix it, but check if it's kernel or user first..
	155	*/
	156	bad_area:
	157	up_read(&mm->mmap_sem);
	158
99a596f9	159	bad_area_nosemaphore:
1da177e4	160	if (user_mode(regs)) {
b5a1bcbe SM	161	info.si_signo = SIGSEGV;
	162	info.si_errno = 0;
	163	info.si_code = si_code;
	164	info.si_addr = (void *) address;
	165	force_sig_info(SIGSEGV, &info, tsk);
1da177e4 LT	166	return;
	167	}
	168
	169	no_context:
	170	/* Are we prepared to handle this kernel fault? */
	171	if (fixup_exception(regs))
	172	return;
	173
e7cc9a73 MD	174	if (handle_trapped_io(regs, address))
e7cc9a73 MD	175	return;
1da177e4 LT	176	/*
	177	* Oops. The kernel tried to access some bad page. We'll have to
	178	* terminate things with extreme prejudice.
	179	*
	180	*/
0630e45c PM	181
	182	bust_spinlocks(1);
	183
	184	if (oops_may_print()) {
b62ad83d	185	unsigned long page;
0630e45c PM	186
	187	if (address < PAGE_SIZE)
	188	printk(KERN_ALERT "Unable to handle kernel NULL "
	189	"pointer dereference");
	190	else
	191	printk(KERN_ALERT "Unable to handle kernel paging "
	192	"request");
	193	printk(" at virtual address %08lx\n", address);
	194	printk(KERN_ALERT "pc = %08lx\n", regs->pc);
	195	page = (unsigned long)get_TTB();
	196	if (page) {
06f862c8	197	page = ((__typeof__(page) *)page)[address >> PGDIR_SHIFT];
0630e45c PM	198	printk(KERN_ALERT "*pde = %08lx\n", page);
	199	if (page & _PAGE_PRESENT) {
	200	page &= PAGE_MASK;
	201	address &= 0x003ff000;
	202	page = ((__typeof__(page) *)
	203	__va(page))[address >>
	204	PAGE_SHIFT];
	205	printk(KERN_ALERT "*pte = %08lx\n", page);
	206	}
1da177e4 LT	207	}
1da177e4 LT	208	}
0630e45c	209
1da177e4	210	die("Oops", regs, writeaccess);
0630e45c	211	bust_spinlocks(0);
1da177e4 LT	212	do_exit(SIGKILL);
	213
	214	/*
	215	* We ran out of memory, or some other thing happened to us that made
	216	* us unable to handle the page fault gracefully.
	217	*/
	218	out_of_memory:
	219	up_read(&mm->mmap_sem);
b460cbc5	220	if (is_global_init(current)) {
1da177e4 LT	221	yield();
	222	down_read(&mm->mmap_sem);
	223	goto survive;
	224	}
	225	printk("VM: killing process %s\n", tsk->comm);
	226	if (user_mode(regs))
dcca2bde	227	do_group_exit(SIGKILL);
1da177e4 LT	228	goto no_context;
	229
	230	do_sigbus:
	231	up_read(&mm->mmap_sem);
	232
	233	/*
	234	* Send a sigbus, regardless of whether we were in kernel
	235	* or user mode.
	236	*/
b5a1bcbe SM	237	info.si_signo = SIGBUS;
	238	info.si_errno = 0;
	239	info.si_code = BUS_ADRERR;
	240	info.si_addr = (void *)address;
	241	force_sig_info(SIGBUS, &info, tsk);
1da177e4 LT	242
	243	/* Kernel mode? Handle exceptions or die */
	244	if (!user_mode(regs))
	245	goto no_context;
	246	}
db2e1fa3	247
3d58695e PM	248	static inline int notify_page_fault(struct pt_regs *regs, int trap)
	249	{
	250	int ret = 0;
	251
3d58695e PM	252	#ifdef CONFIG_KPROBES
	253	if (!user_mode(regs)) {
	254	preempt_disable();
	255	if (kprobe_running() && kprobe_fault_handler(regs, trap))
	256	ret = 1;
	257	preempt_enable();
	258	}
	259	#endif
	260
	261	return ret;
	262	}
	263
db2e1fa3 PM	264	/*
	265	* Called with interrupts disabled.
	266	*/
	267	asmlinkage int __kprobes __do_page_fault(struct pt_regs *regs,
	268	unsigned long writeaccess,
	269	unsigned long address)
	270	{
	271	pgd_t *pgd;
	272	pud_t *pud;
	273	pmd_t *pmd;
	274	pte_t *pte;
	275	pte_t entry;
3d58695e	276	int ret = 0;
db2e1fa3	277
887f1ae3	278	if (notify_page_fault(regs, lookup_exception_vector()))
3d58695e	279	goto out;
037c10a6	280
3d58695e PM	281	ret = 1;
3d58695e PM	282
db2e1fa3 PM	283	/*
	284	* We don't take page faults for P1, P2, and parts of P4, these
	285	* are always mapped, whether it be due to legacy behaviour in
	286	* 29-bit mode, or due to PMB configuration in 32-bit mode.
	287	*/
	288	if (address >= P3SEG && address < P3_ADDR_MAX) {
	289	pgd = pgd_offset_k(address);
db2e1fa3	290	} else {
0f1a394b	291	if (unlikely(address >= TASK_SIZE \|\| !current->mm))
3d58695e	292	goto out;
db2e1fa3	293
0f1a394b	294	pgd = pgd_offset(current->mm, address);
db2e1fa3 PM	295	}
	296
	297	pud = pud_offset(pgd, address);
	298	if (pud_none_or_clear_bad(pud))
3d58695e	299	goto out;
db2e1fa3 PM	300	pmd = pmd_offset(pud, address);
db2e1fa3 PM	301	if (pmd_none_or_clear_bad(pmd))
3d58695e	302	goto out;
0f1a394b	303	pte = pte_offset_kernel(pmd, address);
db2e1fa3 PM	304	entry = *pte;
db2e1fa3 PM	305	if (unlikely(pte_none(entry) \|\| pte_not_present(entry)))
3d58695e	306	goto out;
db2e1fa3	307	if (unlikely(writeaccess && !pte_write(entry)))
3d58695e	308	goto out;
db2e1fa3 PM	309
	310	if (writeaccess)
	311	entry = pte_mkdirty(entry);
	312	entry = pte_mkyoung(entry);
	313
a602cc05 HS	314	#if defined(CONFIG_CPU_SH4) && !defined(CONFIG_SMP)
	315	/*
	316	* ITLB is not affected by "ldtlb" instruction.
	317	* So, we need to flush the entry by ourselves.
	318	*/
	319	local_flush_tlb_one(get_asid(), address & PAGE_MASK);
	320	#endif
	321
db2e1fa3 PM	322	set_pte(pte, entry);
db2e1fa3 PM	323	update_mmu_cache(NULL, address, entry);
0f1a394b	324
3d58695e PM	325	ret = 0;
3d58695e PM	326	out:
3d58695e	327	return ret;
db2e1fa3	328	}