[linux-2.6-block.git] / arch / xtensa / mm / fault.c

// TODO VM_EXEC flag work-around, cache aliasing
/*
 * arch/xtensa/mm/fault.c
 *
 * 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.
 *
 * Copyright (C) 2001 - 2010 Tensilica Inc.
 *
 * Chris Zankel <chris@zankel.net>
 * Joe Taylor	<joe@tensilica.com, joetylr@yahoo.com>
 */

#include <linux/mm.h>
#include <linux/extable.h>
#include <linux/hardirq.h>
#include <linux/perf_event.h>
#include <linux/uaccess.h>
#include <asm/mmu_context.h>
#include <asm/cacheflush.h>
#include <asm/hardirq.h>
#include <asm/pgalloc.h>

DEFINE_PER_CPU(unsigned long, asid_cache) = ASID_USER_FIRST;
void bad_page_fault(struct pt_regs*, unsigned long, int);

/*
 * This routine handles page faults.  It determines the address,
 * and the problem, and then passes it off to one of the appropriate
 * routines.
 *
 * Note: does not handle Miss and MultiHit.
 */

void do_page_fault(struct pt_regs *regs)
{
	struct vm_area_struct * vma;
	struct mm_struct *mm = current->mm;
	unsigned int exccause = regs->exccause;
	unsigned int address = regs->excvaddr;
	int code;

	int is_write, is_exec;
	int fault;
	unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;

	code = SEGV_MAPERR;

	/* We fault-in kernel-space virtual memory on-demand. The
	 * 'reference' page table is init_mm.pgd.
	 */
	if (address >= TASK_SIZE && !user_mode(regs))
		goto vmalloc_fault;

	/* If we're in an interrupt or have no user
	 * context, we must not take the fault..
	 */
	if (faulthandler_disabled() || !mm) {
		bad_page_fault(regs, address, SIGSEGV);
		return;
	}

	is_write = (exccause == EXCCAUSE_STORE_CACHE_ATTRIBUTE) ? 1 : 0;
	is_exec =  (exccause == EXCCAUSE_ITLB_PRIVILEGE ||
		    exccause == EXCCAUSE_ITLB_MISS ||
		    exccause == EXCCAUSE_FETCH_CACHE_ATTRIBUTE) ? 1 : 0;

	pr_debug("[%s:%d:%08x:%d:%08lx:%s%s]\n",
		 current->comm, current->pid,
		 address, exccause, regs->pc,
		 is_write ? "w" : "", is_exec ? "x" : "");

	if (user_mode(regs))
		flags |= FAULT_FLAG_USER;
retry:
	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:
	code = SEGV_ACCERR;

	if (is_write) {
		if (!(vma->vm_flags & VM_WRITE))
			goto bad_area;
		flags |= FAULT_FLAG_WRITE;
	} else if (is_exec) {
		if (!(vma->vm_flags & VM_EXEC))
			goto bad_area;
	} else	/* Allow read even from write-only pages. */
		if (!(vma->vm_flags & (VM_READ | 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.
	 */
	fault = handle_mm_fault(vma, address, flags);

	if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
		return;

	if (unlikely(fault & VM_FAULT_ERROR)) {
		if (fault & VM_FAULT_OOM)
			goto out_of_memory;
		else if (fault & VM_FAULT_SIGSEGV)
			goto bad_area;
		else if (fault & VM_FAULT_SIGBUS)
			goto do_sigbus;
		BUG();
	}
	if (flags & FAULT_FLAG_ALLOW_RETRY) {
		if (fault & VM_FAULT_MAJOR)
			current->maj_flt++;
		else
			current->min_flt++;
		if (fault & VM_FAULT_RETRY) {
			flags &= ~FAULT_FLAG_ALLOW_RETRY;
			flags |= FAULT_FLAG_TRIED;

			 /* No need to up_read(&mm->mmap_sem) as we would
			 * have already released it in __lock_page_or_retry
			 * in mm/filemap.c.
			 */

			goto retry;
		}
	}

	up_read(&mm->mmap_sem);
	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
	if (flags & VM_FAULT_MAJOR)
		perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, regs, address);
	else
		perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, regs, address);

	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);
	if (user_mode(regs)) {
		current->thread.bad_vaddr = address;
		current->thread.error_code = is_write;
		force_sig_fault(SIGSEGV, code, (void *) address, current);
		return;
	}
	bad_page_fault(regs, address, SIGSEGV);
	return;


	/* 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 (!user_mode(regs))
		bad_page_fault(regs, address, SIGKILL);
	else
		pagefault_out_of_memory();
	return;

do_sigbus:
	up_read(&mm->mmap_sem);

	/* Send a sigbus, regardless of whether we were in kernel
	 * or user mode.
	 */
	current->thread.bad_vaddr = address;
	force_sig_fault(SIGBUS, BUS_ADRERR, (void *) address, current);

	/* Kernel mode? Handle exceptions or die */
	if (!user_mode(regs))
		bad_page_fault(regs, address, SIGBUS);
	return;

vmalloc_fault:
	{
		/* Synchronize this task's top level page-table
		 * with the 'reference' page table.
		 */
		struct mm_struct *act_mm = current->active_mm;
		int index = pgd_index(address);
		pgd_t *pgd, *pgd_k;
		pmd_t *pmd, *pmd_k;
		pte_t *pte_k;

		if (act_mm == NULL)
			goto bad_page_fault;

		pgd = act_mm->pgd + index;
		pgd_k = init_mm.pgd + index;

		if (!pgd_present(*pgd_k))
			goto bad_page_fault;

		pgd_val(*pgd) = pgd_val(*pgd_k);

		pmd = pmd_offset(pgd, address);
		pmd_k = pmd_offset(pgd_k, address);
		if (!pmd_present(*pmd) || !pmd_present(*pmd_k))
			goto bad_page_fault;

		pmd_val(*pmd) = pmd_val(*pmd_k);
		pte_k = pte_offset_kernel(pmd_k, address);

		if (!pte_present(*pte_k))
			goto bad_page_fault;
		return;
	}
bad_page_fault:
	bad_page_fault(regs, address, SIGKILL);
	return;
}


void
bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
{
	extern void die(const char*, struct pt_regs*, long);
	const struct exception_table_entry *entry;

	/* Are we prepared to handle this kernel fault?  */
	if ((entry = search_exception_tables(regs->pc)) != NULL) {
		pr_debug("%s: Exception at pc=%#010lx (%lx)\n",
			 current->comm, regs->pc, entry->fixup);
		current->thread.bad_uaddr = address;
		regs->pc = entry->fixup;
		return;
	}

	/* Oops. The kernel tried to access some bad page. We'll have to
	 * terminate things with extreme prejudice.
	 */
	pr_alert("Unable to handle kernel paging request at virtual "
		 "address %08lx\n pc = %08lx, ra = %08lx\n",
		 address, regs->pc, regs->areg[0]);
	die("Oops", regs, sig);
	do_exit(sig);
}
Commit	Line	Data
3f65ce4d CZ	1	// TODO VM_EXEC flag work-around, cache aliasing
	2	/*
	3	* arch/xtensa/mm/fault.c
	4	*
	5	* This file is subject to the terms and conditions of the GNU General Public
	6	* License. See the file "COPYING" in the main directory of this archive
	7	* for more details.
	8	*
1bbedc3a	9	* Copyright (C) 2001 - 2010 Tensilica Inc.
3f65ce4d CZ	10	*
	11	* Chris Zankel <chris@zankel.net>
	12	* Joe Taylor <joe@tensilica.com, joetylr@yahoo.com>
	13	*/
	14
	15	#include <linux/mm.h>
6cc306ea	16	#include <linux/extable.h>
5a891ed5	17	#include <linux/hardirq.h>
af885de8	18	#include <linux/perf_event.h>
70ffdb93	19	#include <linux/uaccess.h>
3f65ce4d CZ	20	#include <asm/mmu_context.h>
	21	#include <asm/cacheflush.h>
	22	#include <asm/hardirq.h>
3f65ce4d CZ	23	#include <asm/pgalloc.h>
3f65ce4d CZ	24
f615136c	25	DEFINE_PER_CPU(unsigned long, asid_cache) = ASID_USER_FIRST;
3f65ce4d CZ	26	void bad_page_fault(struct pt_regs*, unsigned long, int);
	27
	28	/*
	29	* This routine handles page faults. It determines the address,
	30	* and the problem, and then passes it off to one of the appropriate
	31	* routines.
	32	*
	33	* Note: does not handle Miss and MultiHit.
	34	*/
	35
	36	void do_page_fault(struct pt_regs *regs)
	37	{
	38	struct vm_area_struct * vma;
	39	struct mm_struct *mm = current->mm;
	40	unsigned int exccause = regs->exccause;
	41	unsigned int address = regs->excvaddr;
91810105	42	int code;
3f65ce4d CZ	43
3f65ce4d CZ	44	int is_write, is_exec;
83c54070	45	int fault;
f107701f	46	unsigned int flags = FAULT_FLAG_ALLOW_RETRY \| FAULT_FLAG_KILLABLE;
3f65ce4d	47
91810105	48	code = SEGV_MAPERR;
3f65ce4d CZ	49
	50	/* We fault-in kernel-space virtual memory on-demand. The
	51	* 'reference' page table is init_mm.pgd.
	52	*/
	53	if (address >= TASK_SIZE && !user_mode(regs))
	54	goto vmalloc_fault;
	55
	56	/* If we're in an interrupt or have no user
	57	* context, we must not take the fault..
	58	*/
70ffdb93	59	if (faulthandler_disabled() \|\| !mm) {
3f65ce4d CZ	60	bad_page_fault(regs, address, SIGSEGV);
	61	return;
	62	}
	63
173d6681 CZ	64	is_write = (exccause == EXCCAUSE_STORE_CACHE_ATTRIBUTE) ? 1 : 0;
	65	is_exec = (exccause == EXCCAUSE_ITLB_PRIVILEGE \|\|
	66	exccause == EXCCAUSE_ITLB_MISS \|\|
	67	exccause == EXCCAUSE_FETCH_CACHE_ATTRIBUTE) ? 1 : 0;
3f65ce4d	68
c130d3be MF	69	pr_debug("[%s:%d:%08x:%d:%08lx:%s%s]\n",
	70	current->comm, current->pid,
	71	address, exccause, regs->pc,
	72	is_write ? "w" : "", is_exec ? "x" : "");
3f65ce4d	73
759496ba JW	74	if (user_mode(regs))
759496ba JW	75	flags \|= FAULT_FLAG_USER;
f107701f	76	retry:
3f65ce4d CZ	77	down_read(&mm->mmap_sem);
	78	vma = find_vma(mm, address);
	79
	80	if (!vma)
	81	goto bad_area;
	82	if (vma->vm_start <= address)
	83	goto good_area;
	84	if (!(vma->vm_flags & VM_GROWSDOWN))
	85	goto bad_area;
	86	if (expand_stack(vma, address))
	87	goto bad_area;
	88
	89	/* Ok, we have a good vm_area for this memory access, so
	90	* we can handle it..
	91	*/
	92
	93	good_area:
91810105	94	code = SEGV_ACCERR;
3f65ce4d CZ	95
	96	if (is_write) {
	97	if (!(vma->vm_flags & VM_WRITE))
	98	goto bad_area;
f107701f	99	flags \|= FAULT_FLAG_WRITE;
3f65ce4d CZ	100	} else if (is_exec) {
	101	if (!(vma->vm_flags & VM_EXEC))
	102	goto bad_area;
	103	} else /* Allow read even from write-only pages. */
	104	if (!(vma->vm_flags & (VM_READ \| VM_WRITE)))
	105	goto bad_area;
	106
	107	/* If for any reason at all we couldn't handle the fault,
	108	* make sure we exit gracefully rather than endlessly redo
	109	* the fault.
	110	*/
dcddffd4	111	fault = handle_mm_fault(vma, address, flags);
f107701f KC	112
	113	if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
	114	return;
	115
83c54070 NP	116	if (unlikely(fault & VM_FAULT_ERROR)) {
	117	if (fault & VM_FAULT_OOM)
	118	goto out_of_memory;
33692f27 LT	119	else if (fault & VM_FAULT_SIGSEGV)
33692f27 LT	120	goto bad_area;
83c54070 NP	121	else if (fault & VM_FAULT_SIGBUS)
83c54070 NP	122	goto do_sigbus;
3f65ce4d CZ	123	BUG();
3f65ce4d CZ	124	}
f107701f KC	125	if (flags & FAULT_FLAG_ALLOW_RETRY) {
	126	if (fault & VM_FAULT_MAJOR)
	127	current->maj_flt++;
	128	else
	129	current->min_flt++;
	130	if (fault & VM_FAULT_RETRY) {
	131	flags &= ~FAULT_FLAG_ALLOW_RETRY;
45cac65b	132	flags \|= FAULT_FLAG_TRIED;
f107701f KC	133
	134	/* No need to up_read(&mm->mmap_sem) as we would
	135	* have already released it in __lock_page_or_retry
	136	* in mm/filemap.c.
	137	*/
	138
	139	goto retry;
	140	}
	141	}
3f65ce4d CZ	142
3f65ce4d CZ	143	up_read(&mm->mmap_sem);
af885de8 MF	144	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
	145	if (flags & VM_FAULT_MAJOR)
	146	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, regs, address);
0e8fb931	147	else
af885de8 MF	148	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, regs, address);
af885de8 MF	149
3f65ce4d CZ	150	return;
	151
	152	/* Something tried to access memory that isn't in our memory map..
	153	* Fix it, but check if it's kernel or user first..
	154	*/
	155	bad_area:
	156	up_read(&mm->mmap_sem);
	157	if (user_mode(regs)) {
	158	current->thread.bad_vaddr = address;
	159	current->thread.error_code = is_write;
91810105	160	force_sig_fault(SIGSEGV, code, (void *) address, current);
3f65ce4d CZ	161	return;
	162	}
	163	bad_page_fault(regs, address, SIGSEGV);
	164	return;
	165
	166
	167	/* We ran out of memory, or some other thing happened to us that made
	168	* us unable to handle the page fault gracefully.
	169	*/
	170	out_of_memory:
	171	up_read(&mm->mmap_sem);
f76f5d71 NP	172	if (!user_mode(regs))
	173	bad_page_fault(regs, address, SIGKILL);
	174	else
	175	pagefault_out_of_memory();
3f65ce4d CZ	176	return;
	177
	178	do_sigbus:
	179	up_read(&mm->mmap_sem);
	180
	181	/* Send a sigbus, regardless of whether we were in kernel
	182	* or user mode.
	183	*/
	184	current->thread.bad_vaddr = address;
91810105	185	force_sig_fault(SIGBUS, BUS_ADRERR, (void *) address, current);
3f65ce4d CZ	186
	187	/* Kernel mode? Handle exceptions or die */
	188	if (!user_mode(regs))
	189	bad_page_fault(regs, address, SIGBUS);
1bbedc3a	190	return;
3f65ce4d CZ	191
	192	vmalloc_fault:
	193	{
	194	/* Synchronize this task's top level page-table
	195	* with the 'reference' page table.
	196	*/
	197	struct mm_struct *act_mm = current->active_mm;
	198	int index = pgd_index(address);
	199	pgd_t pgd, pgd_k;
	200	pmd_t pmd, pmd_k;
	201	pte_t *pte_k;
	202
	203	if (act_mm == NULL)
	204	goto bad_page_fault;
	205
	206	pgd = act_mm->pgd + index;
	207	pgd_k = init_mm.pgd + index;
	208
	209	if (!pgd_present(*pgd_k))
	210	goto bad_page_fault;
	211
	212	pgd_val(pgd) = pgd_val(pgd_k);
	213
	214	pmd = pmd_offset(pgd, address);
	215	pmd_k = pmd_offset(pgd_k, address);
	216	if (!pmd_present(pmd) \|\| !pmd_present(pmd_k))
	217	goto bad_page_fault;
	218
	219	pmd_val(pmd) = pmd_val(pmd_k);
	220	pte_k = pte_offset_kernel(pmd_k, address);
	221
	222	if (!pte_present(*pte_k))
	223	goto bad_page_fault;
	224	return;
	225	}
	226	bad_page_fault:
	227	bad_page_fault(regs, address, SIGKILL);
	228	return;
	229	}
	230
	231
	232	void
	233	bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
	234	{
	235	extern void die(const char, struct pt_regs, long);
	236	const struct exception_table_entry *entry;
	237
	238	/* Are we prepared to handle this kernel fault? */
	239	if ((entry = search_exception_tables(regs->pc)) != NULL) {
c130d3be MF	240	pr_debug("%s: Exception at pc=%#010lx (%lx)\n",
c130d3be MF	241	current->comm, regs->pc, entry->fixup);
3f65ce4d CZ	242	current->thread.bad_uaddr = address;
	243	regs->pc = entry->fixup;
	244	return;
	245	}
	246
	247	/* Oops. The kernel tried to access some bad page. We'll have to
	248	* terminate things with extreme prejudice.
	249	*/
c130d3be MF	250	pr_alert("Unable to handle kernel paging request at virtual "
	251	"address %08lx\n pc = %08lx, ra = %08lx\n",
	252	address, regs->pc, regs->areg[0]);
3f65ce4d CZ	253	die("Oops", regs, sig);
	254	do_exit(sig);
	255	}