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

// SPDX-License-Identifier: GPL-2.0
/*
 * fault.c:  Page fault handlers for the Sparc.
 *
 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
 * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
 * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
 */

#include <asm/head.h>

#include <linux/string.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/ptrace.h>
#include <linux/mman.h>
#include <linux/threads.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/perf_event.h>
#include <linux/interrupt.h>
#include <linux/kdebug.h>
#include <linux/uaccess.h>

#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/openprom.h>
#include <asm/oplib.h>
#include <asm/setup.h>
#include <asm/smp.h>
#include <asm/traps.h>

#include "mm_32.h"

int show_unhandled_signals = 1;

static void __noreturn unhandled_fault(unsigned long address,
				       struct task_struct *tsk,
				       struct pt_regs *regs)
{
	if ((unsigned long) address < PAGE_SIZE) {
		printk(KERN_ALERT
		    "Unable to handle kernel NULL pointer dereference\n");
	} else {
		printk(KERN_ALERT "Unable to handle kernel paging request at virtual address %08lx\n",
		       address);
	}
	printk(KERN_ALERT "tsk->{mm,active_mm}->context = %08lx\n",
		(tsk->mm ? tsk->mm->context : tsk->active_mm->context));
	printk(KERN_ALERT "tsk->{mm,active_mm}->pgd = %08lx\n",
		(tsk->mm ? (unsigned long) tsk->mm->pgd :
			(unsigned long) tsk->active_mm->pgd));
	die_if_kernel("Oops", regs);
}

asmlinkage int lookup_fault(unsigned long pc, unsigned long ret_pc,
			    unsigned long address)
{
	struct pt_regs regs;
	unsigned long g2;
	unsigned int insn;
	int i;

	i = search_extables_range(ret_pc, &g2);
	switch (i) {
	case 3:
		/* load & store will be handled by fixup */
		return 3;

	case 1:
		/* store will be handled by fixup, load will bump out */
		/* for _to_ macros */
		insn = *((unsigned int *) pc);
		if ((insn >> 21) & 1)
			return 1;
		break;

	case 2:
		/* load will be handled by fixup, store will bump out */
		/* for _from_ macros */
		insn = *((unsigned int *) pc);
		if (!((insn >> 21) & 1) || ((insn>>19)&0x3f) == 15)
			return 2;
		break;

	default:
		break;
	}

	memset(&regs, 0, sizeof(regs));
	regs.pc = pc;
	regs.npc = pc + 4;
	__asm__ __volatile__(
		"rd %%psr, %0\n\t"
		"nop\n\t"
		"nop\n\t"
		"nop\n" : "=r" (regs.psr));
	unhandled_fault(address, current, &regs);

	/* Not reached */
	return 0;
}

static inline void
show_signal_msg(struct pt_regs *regs, int sig, int code,
		unsigned long address, struct task_struct *tsk)
{
	if (!unhandled_signal(tsk, sig))
		return;

	if (!printk_ratelimit())
		return;

	printk("%s%s[%d]: segfault at %lx ip %px (rpc %px) sp %px error %x",
	       task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG,
	       tsk->comm, task_pid_nr(tsk), address,
	       (void *)regs->pc, (void *)regs->u_regs[UREG_I7],
	       (void *)regs->u_regs[UREG_FP], code);

	print_vma_addr(KERN_CONT " in ", regs->pc);

	printk(KERN_CONT "\n");
}

static void __do_fault_siginfo(int code, int sig, struct pt_regs *regs,
			       unsigned long addr)
{
	if (unlikely(show_unhandled_signals))
		show_signal_msg(regs, sig, code,
				addr, current);

	force_sig_fault(sig, code, (void __user *) addr, 0);
}

static unsigned long compute_si_addr(struct pt_regs *regs, int text_fault)
{
	unsigned int insn;

	if (text_fault)
		return regs->pc;

	if (regs->psr & PSR_PS)
		insn = *(unsigned int *) regs->pc;
	else
		__get_user(insn, (unsigned int *) regs->pc);

	return safe_compute_effective_address(regs, insn);
}

static noinline void do_fault_siginfo(int code, int sig, struct pt_regs *regs,
				      int text_fault)
{
	unsigned long addr = compute_si_addr(regs, text_fault);

	__do_fault_siginfo(code, sig, regs, addr);
}

asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write,
			       unsigned long address)
{
	struct vm_area_struct *vma;
	struct task_struct *tsk = current;
	struct mm_struct *mm = tsk->mm;
	unsigned int fixup;
	unsigned long g2;
	int from_user = !(regs->psr & PSR_PS);
	int code;
	vm_fault_t fault;
	unsigned int flags = FAULT_FLAG_DEFAULT;

	if (text_fault)
		address = regs->pc;

	/*
	 * We fault-in kernel-space virtual memory on-demand. The
	 * 'reference' page table is init_mm.pgd.
	 *
	 * NOTE! We MUST NOT take any locks for this case. We may
	 * be in an interrupt or a critical region, and should
	 * only copy the information from the master page table,
	 * nothing more.
	 */
	code = SEGV_MAPERR;
	if (address >= TASK_SIZE)
		goto vmalloc_fault;

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

	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);

retry:
	down_read(&mm->mmap_sem);

	if (!from_user && address >= PAGE_OFFSET)
		goto bad_area;

	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 (write) {
		if (!(vma->vm_flags & VM_WRITE))
			goto bad_area;
	} else {
		/* Allow reads even for write-only mappings */
		if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
			goto bad_area;
	}

	if (from_user)
		flags |= FAULT_FLAG_USER;
	if (write)
		flags |= FAULT_FLAG_WRITE;

	/*
	 * 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_signal_pending(fault, regs))
		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++;
			perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ,
				      1, regs, address);
		} else {
			current->min_flt++;
			perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN,
				      1, regs, address);
		}
		if (fault & VM_FAULT_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);
	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:
	/* User mode accesses just cause a SIGSEGV */
	if (from_user) {
		do_fault_siginfo(code, SIGSEGV, regs, text_fault);
		return;
	}

	/* Is this in ex_table? */
no_context:
	g2 = regs->u_regs[UREG_G2];
	if (!from_user) {
		fixup = search_extables_range(regs->pc, &g2);
		/* Values below 10 are reserved for other things */
		if (fixup > 10) {
			extern const unsigned int __memset_start[];
			extern const unsigned int __memset_end[];
			extern const unsigned int __csum_partial_copy_start[];
			extern const unsigned int __csum_partial_copy_end[];

#ifdef DEBUG_EXCEPTIONS
			printk("Exception: PC<%08lx> faddr<%08lx>\n",
			       regs->pc, address);
			printk("EX_TABLE: insn<%08lx> fixup<%08x> g2<%08lx>\n",
				regs->pc, fixup, g2);
#endif
			if ((regs->pc >= (unsigned long)__memset_start &&
			     regs->pc < (unsigned long)__memset_end) ||
			    (regs->pc >= (unsigned long)__csum_partial_copy_start &&
			     regs->pc < (unsigned long)__csum_partial_copy_end)) {
				regs->u_regs[UREG_I4] = address;
				regs->u_regs[UREG_I5] = regs->pc;
			}
			regs->u_regs[UREG_G2] = g2;
			regs->pc = fixup;
			regs->npc = regs->pc + 4;
			return;
		}
	}

	unhandled_fault(address, tsk, regs);
	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 (from_user) {
		pagefault_out_of_memory();
		return;
	}
	goto no_context;

do_sigbus:
	up_read(&mm->mmap_sem);
	do_fault_siginfo(BUS_ADRERR, SIGBUS, regs, text_fault);
	if (!from_user)
		goto no_context;

vmalloc_fault:
	{
		/*
		 * Synchronize this task's top level page-table
		 * with the 'reference' page table.
		 */
		int offset = pgd_index(address);
		pgd_t *pgd, *pgd_k;
		p4d_t *p4d, *p4d_k;
		pud_t *pud, *pud_k;
		pmd_t *pmd, *pmd_k;

		pgd = tsk->active_mm->pgd + offset;
		pgd_k = init_mm.pgd + offset;

		if (!pgd_present(*pgd)) {
			if (!pgd_present(*pgd_k))
				goto bad_area_nosemaphore;
			pgd_val(*pgd) = pgd_val(*pgd_k);
			return;
		}

		p4d = p4d_offset(pgd, address);
		pud = pud_offset(p4d, address);
		pmd = pmd_offset(pud, address);

		p4d_k = p4d_offset(pgd_k, address);
		pud_k = pud_offset(p4d_k, address);
		pmd_k = pmd_offset(pud_k, address);

		if (pmd_present(*pmd) || !pmd_present(*pmd_k))
			goto bad_area_nosemaphore;

		*pmd = *pmd_k;
		return;
	}
}

/* This always deals with user addresses. */
static void force_user_fault(unsigned long address, int write)
{
	struct vm_area_struct *vma;
	struct task_struct *tsk = current;
	struct mm_struct *mm = tsk->mm;
	unsigned int flags = FAULT_FLAG_USER;
	int code;

	code = SEGV_MAPERR;

	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;
good_area:
	code = SEGV_ACCERR;
	if (write) {
		if (!(vma->vm_flags & VM_WRITE))
			goto bad_area;
		flags |= FAULT_FLAG_WRITE;
	} else {
		if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
			goto bad_area;
	}
	switch (handle_mm_fault(vma, address, flags)) {
	case VM_FAULT_SIGBUS:
	case VM_FAULT_OOM:
		goto do_sigbus;
	}
	up_read(&mm->mmap_sem);
	return;
bad_area:
	up_read(&mm->mmap_sem);
	__do_fault_siginfo(code, SIGSEGV, tsk->thread.kregs, address);
	return;

do_sigbus:
	up_read(&mm->mmap_sem);
	__do_fault_siginfo(BUS_ADRERR, SIGBUS, tsk->thread.kregs, address);
}

static void check_stack_aligned(unsigned long sp)
{
	if (sp & 0x7UL)
		force_sig(SIGILL);
}

void window_overflow_fault(void)
{
	unsigned long sp;

	sp = current_thread_info()->rwbuf_stkptrs[0];
	if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
		force_user_fault(sp + 0x38, 1);
	force_user_fault(sp, 1);

	check_stack_aligned(sp);
}

void window_underflow_fault(unsigned long sp)
{
	if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
		force_user_fault(sp + 0x38, 0);
	force_user_fault(sp, 0);

	check_stack_aligned(sp);
}

void window_ret_fault(struct pt_regs *regs)
{
	unsigned long sp;

	sp = regs->u_regs[UREG_FP];
	if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
		force_user_fault(sp + 0x38, 0);
	force_user_fault(sp, 0);

	check_stack_aligned(sp);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
88278ca2	2	/*
1da177e4 LT	3	* fault.c: Page fault handlers for the Sparc.
	4	*
	5	* Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
	6	* Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
	7	* Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
	8	*/
	9
	10	#include <asm/head.h>
	11
	12	#include <linux/string.h>
	13	#include <linux/types.h>
	14	#include <linux/sched.h>
	15	#include <linux/ptrace.h>
	16	#include <linux/mman.h>
	17	#include <linux/threads.h>
	18	#include <linux/kernel.h>
	19	#include <linux/signal.h>
	20	#include <linux/mm.h>
	21	#include <linux/smp.h>
a084b667	22	#include <linux/perf_event.h>
1da177e4	23	#include <linux/interrupt.h>
1eeb66a1	24	#include <linux/kdebug.h>
70ffdb93	25	#include <linux/uaccess.h>
1da177e4	26
1da177e4 LT	27	#include <asm/page.h>
1da177e4 LT	28	#include <asm/pgtable.h>
1da177e4 LT	29	#include <asm/openprom.h>
1da177e4 LT	30	#include <asm/oplib.h>
9edfae3f	31	#include <asm/setup.h>
1da177e4 LT	32	#include <asm/smp.h>
1da177e4 LT	33	#include <asm/traps.h>
1da177e4	34
e1b2f134	35	#include "mm_32.h"
4b177647	36
e1b2f134	37	int show_unhandled_signals = 1;
1da177e4	38
70168dfa SR	39	static void __noreturn unhandled_fault(unsigned long address,
	40	struct task_struct *tsk,
	41	struct pt_regs *regs)
1da177e4	42	{
70168dfa	43	if ((unsigned long) address < PAGE_SIZE) {
1da177e4 LT	44	printk(KERN_ALERT
	45	"Unable to handle kernel NULL pointer dereference\n");
	46	} else {
70168dfa SR	47	printk(KERN_ALERT "Unable to handle kernel paging request at virtual address %08lx\n",
70168dfa SR	48	address);
1da177e4 LT	49	}
	50	printk(KERN_ALERT "tsk->{mm,active_mm}->context = %08lx\n",
	51	(tsk->mm ? tsk->mm->context : tsk->active_mm->context));
	52	printk(KERN_ALERT "tsk->{mm,active_mm}->pgd = %08lx\n",
	53	(tsk->mm ? (unsigned long) tsk->mm->pgd :
70168dfa	54	(unsigned long) tsk->active_mm->pgd));
1da177e4 LT	55	die_if_kernel("Oops", regs);
	56	}
	57
70168dfa	58	asmlinkage int lookup_fault(unsigned long pc, unsigned long ret_pc,
1da177e4 LT	59	unsigned long address)
	60	{
	61	struct pt_regs regs;
	62	unsigned long g2;
	63	unsigned int insn;
	64	int i;
70168dfa	65
1da177e4 LT	66	i = search_extables_range(ret_pc, &g2);
	67	switch (i) {
	68	case 3:
	69	/* load & store will be handled by fixup */
	70	return 3;
	71
	72	case 1:
	73	/* store will be handled by fixup, load will bump out */
	74	/* for _to_ macros */
	75	insn = ((unsigned int ) pc);
	76	if ((insn >> 21) & 1)
	77	return 1;
	78	break;
	79
	80	case 2:
	81	/* load will be handled by fixup, store will bump out */
	82	/* for _from_ macros */
	83	insn = ((unsigned int ) pc);
	84	if (!((insn >> 21) & 1) \|\| ((insn>>19)&0x3f) == 15)
70168dfa SR	85	return 2;
70168dfa SR	86	break;
1da177e4 LT	87
	88	default:
	89	break;
6cb79b3f	90	}
1da177e4	91
70168dfa	92	memset(&regs, 0, sizeof(regs));
1da177e4 LT	93	regs.pc = pc;
	94	regs.npc = pc + 4;
	95	__asm__ __volatile__(
	96	"rd %%psr, %0\n\t"
	97	"nop\n\t"
	98	"nop\n\t"
	99	"nop\n" : "=r" (regs.psr));
	100	unhandled_fault(address, current, &regs);
	101
	102	/* Not reached */
	103	return 0;
	104	}
	105
4b177647 DM	106	static inline void
	107	show_signal_msg(struct pt_regs *regs, int sig, int code,
	108	unsigned long address, struct task_struct *tsk)
	109	{
	110	if (!unhandled_signal(tsk, sig))
	111	return;
	112
	113	if (!printk_ratelimit())
	114	return;
	115
10a7e9d8	116	printk("%s%s[%d]: segfault at %lx ip %px (rpc %px) sp %px error %x",
4b177647 DM	117	task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG,
	118	tsk->comm, task_pid_nr(tsk), address,
	119	(void )regs->pc, (void )regs->u_regs[UREG_I7],
	120	(void *)regs->u_regs[UREG_FP], code);
	121
	122	print_vma_addr(KERN_CONT " in ", regs->pc);
	123
	124	printk(KERN_CONT "\n");
	125	}
	126
	127	static void __do_fault_siginfo(int code, int sig, struct pt_regs *regs,
	128	unsigned long addr)
	129	{
4b177647	130	if (unlikely(show_unhandled_signals))
d1f5bef6	131	show_signal_msg(regs, sig, code,
4b177647 DM	132	addr, current);
4b177647 DM	133
2e1661d2	134	force_sig_fault(sig, code, (void __user *) addr, 0);
4b177647 DM	135	}
4b177647 DM	136
1da177e4 LT	137	static unsigned long compute_si_addr(struct pt_regs *regs, int text_fault)
	138	{
	139	unsigned int insn;
	140
	141	if (text_fault)
	142	return regs->pc;
	143
70168dfa	144	if (regs->psr & PSR_PS)
1da177e4	145	insn = (unsigned int ) regs->pc;
70168dfa	146	else
1da177e4	147	__get_user(insn, (unsigned int *) regs->pc);
1da177e4 LT	148
	149	return safe_compute_effective_address(regs, insn);
	150	}
	151
4b177647 DM	152	static noinline void do_fault_siginfo(int code, int sig, struct pt_regs *regs,
	153	int text_fault)
	154	{
	155	unsigned long addr = compute_si_addr(regs, text_fault);
	156
	157	__do_fault_siginfo(code, sig, regs, addr);
	158	}
	159
1da177e4 LT	160	asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write,
	161	unsigned long address)
	162	{
	163	struct vm_area_struct *vma;
	164	struct task_struct *tsk = current;
	165	struct mm_struct *mm = tsk->mm;
	166	unsigned int fixup;
	167	unsigned long g2;
1da177e4	168	int from_user = !(regs->psr & PSR_PS);
50a7ca3c SJ	169	int code;
50a7ca3c SJ	170	vm_fault_t fault;
dde16072	171	unsigned int flags = FAULT_FLAG_DEFAULT;
1da177e4	172
70168dfa	173	if (text_fault)
1da177e4 LT	174	address = regs->pc;
	175
	176	/*
	177	* We fault-in kernel-space virtual memory on-demand. The
	178	* 'reference' page table is init_mm.pgd.
	179	*
	180	* NOTE! We MUST NOT take any locks for this case. We may
	181	* be in an interrupt or a critical region, and should
	182	* only copy the information from the master page table,
	183	* nothing more.
	184	*/
c816be7b	185	code = SEGV_MAPERR;
582a0bae	186	if (address >= TASK_SIZE)
1da177e4 LT	187	goto vmalloc_fault;
1da177e4 LT	188
1da177e4 LT	189	/*
	190	* If we're in an interrupt or have no user
	191	* context, we must not take the fault..
	192	*/
70ffdb93	193	if (pagefault_disabled() \|\| !mm)
70168dfa	194	goto no_context;
1da177e4	195
a8b0ca17	196	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
a084b667	197
c29554f5	198	retry:
1da177e4 LT	199	down_read(&mm->mmap_sem);
1da177e4 LT	200
70168dfa	201	if (!from_user && address >= PAGE_OFFSET)
1da177e4 LT	202	goto bad_area;
	203
	204	vma = find_vma(mm, address);
70168dfa	205	if (!vma)
1da177e4	206	goto bad_area;
70168dfa	207	if (vma->vm_start <= address)
1da177e4	208	goto good_area;
70168dfa	209	if (!(vma->vm_flags & VM_GROWSDOWN))
1da177e4	210	goto bad_area;
70168dfa	211	if (expand_stack(vma, address))
1da177e4 LT	212	goto bad_area;
	213	/*
	214	* Ok, we have a good vm_area for this memory access, so
	215	* we can handle it..
	216	*/
	217	good_area:
4b177647	218	code = SEGV_ACCERR;
70168dfa SR	219	if (write) {
70168dfa SR	220	if (!(vma->vm_flags & VM_WRITE))
1da177e4 LT	221	goto bad_area;
	222	} else {
	223	/* Allow reads even for write-only mappings */
70168dfa	224	if (!(vma->vm_flags & (VM_READ \| VM_EXEC)))
1da177e4 LT	225	goto bad_area;
	226	}
	227
759496ba JW	228	if (from_user)
	229	flags \|= FAULT_FLAG_USER;
	230	if (write)
	231	flags \|= FAULT_FLAG_WRITE;
	232
1da177e4 LT	233	/*
	234	* If for any reason at all we couldn't handle the fault,
	235	* make sure we exit gracefully rather than endlessly redo
	236	* the fault.
	237	*/
dcddffd4	238	fault = handle_mm_fault(vma, address, flags);
c29554f5	239
4ef87322	240	if (fault_signal_pending(fault, regs))
c29554f5 KC	241	return;
c29554f5 KC	242
83c54070 NP	243	if (unlikely(fault & VM_FAULT_ERROR)) {
	244	if (fault & VM_FAULT_OOM)
	245	goto out_of_memory;
33692f27 LT	246	else if (fault & VM_FAULT_SIGSEGV)
33692f27 LT	247	goto bad_area;
83c54070 NP	248	else if (fault & VM_FAULT_SIGBUS)
	249	goto do_sigbus;
	250	BUG();
	251	}
c29554f5 KC	252
	253	if (flags & FAULT_FLAG_ALLOW_RETRY) {
	254	if (fault & VM_FAULT_MAJOR) {
	255	current->maj_flt++;
	256	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ,
	257	1, regs, address);
	258	} else {
	259	current->min_flt++;
	260	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN,
	261	1, regs, address);
	262	}
	263	if (fault & VM_FAULT_RETRY) {
45cac65b	264	flags \|= FAULT_FLAG_TRIED;
c29554f5 KC	265
	266	/* No need to up_read(&mm->mmap_sem) as we would
	267	* have already released it in __lock_page_or_retry
	268	* in mm/filemap.c.
	269	*/
	270
	271	goto retry;
	272	}
a084b667	273	}
c29554f5	274
1da177e4 LT	275	up_read(&mm->mmap_sem);
	276	return;
	277
	278	/*
	279	* Something tried to access memory that isn't in our memory map..
	280	* Fix it, but check if it's kernel or user first..
	281	*/
	282	bad_area:
	283	up_read(&mm->mmap_sem);
	284
	285	bad_area_nosemaphore:
	286	/* User mode accesses just cause a SIGSEGV */
4b177647 DM	287	if (from_user) {
4b177647 DM	288	do_fault_siginfo(code, SIGSEGV, regs, text_fault);
1da177e4 LT	289	return;
	290	}
	291
	292	/* Is this in ex_table? */
	293	no_context:
	294	g2 = regs->u_regs[UREG_G2];
0157141a SR	295	if (!from_user) {
0157141a SR	296	fixup = search_extables_range(regs->pc, &g2);
70168dfa SR	297	/* Values below 10 are reserved for other things */
70168dfa SR	298	if (fixup > 10) {
9ef595d8 JP	299	extern const unsigned int __memset_start[];
	300	extern const unsigned int __memset_end[];
	301	extern const unsigned int __csum_partial_copy_start[];
	302	extern const unsigned int __csum_partial_copy_end[];
1da177e4 LT	303
1da177e4 LT	304	#ifdef DEBUG_EXCEPTIONS
70168dfa SR	305	printk("Exception: PC<%08lx> faddr<%08lx>\n",
70168dfa SR	306	regs->pc, address);
1da177e4 LT	307	printk("EX_TABLE: insn<%08lx> fixup<%08x> g2<%08lx>\n",
	308	regs->pc, fixup, g2);
	309	#endif
	310	if ((regs->pc >= (unsigned long)__memset_start &&
	311	regs->pc < (unsigned long)__memset_end) \|\|
	312	(regs->pc >= (unsigned long)__csum_partial_copy_start &&
	313	regs->pc < (unsigned long)__csum_partial_copy_end)) {
70168dfa	314	regs->u_regs[UREG_I4] = address;
1da177e4 LT	315	regs->u_regs[UREG_I5] = regs->pc;
	316	}
	317	regs->u_regs[UREG_G2] = g2;
	318	regs->pc = fixup;
	319	regs->npc = regs->pc + 4;
	320	return;
	321	}
	322	}
70168dfa SR	323
70168dfa SR	324	unhandled_fault(address, tsk, regs);
1da177e4 LT	325	do_exit(SIGKILL);
	326
	327	/*
	328	* We ran out of memory, or some other thing happened to us that made
	329	* us unable to handle the page fault gracefully.
	330	*/
	331	out_of_memory:
	332	up_read(&mm->mmap_sem);
a923c28f DM	333	if (from_user) {
	334	pagefault_out_of_memory();
	335	return;
	336	}
1da177e4 LT	337	goto no_context;
	338
	339	do_sigbus:
	340	up_read(&mm->mmap_sem);
4b177647	341	do_fault_siginfo(BUS_ADRERR, SIGBUS, regs, text_fault);
1da177e4 LT	342	if (!from_user)
	343	goto no_context;
	344
	345	vmalloc_fault:
	346	{
	347	/*
	348	* Synchronize this task's top level page-table
	349	* with the 'reference' page table.
	350	*/
	351	int offset = pgd_index(address);
	352	pgd_t pgd, pgd_k;
7235db26 MR	353	p4d_t p4d, p4d_k;
7235db26 MR	354	pud_t pud, pud_k;
1da177e4 LT	355	pmd_t pmd, pmd_k;
	356
	357	pgd = tsk->active_mm->pgd + offset;
	358	pgd_k = init_mm.pgd + offset;
	359
	360	if (!pgd_present(*pgd)) {
	361	if (!pgd_present(*pgd_k))
	362	goto bad_area_nosemaphore;
	363	pgd_val(pgd) = pgd_val(pgd_k);
	364	return;
	365	}
	366
7235db26 MR	367	p4d = p4d_offset(pgd, address);
	368	pud = pud_offset(p4d, address);
	369	pmd = pmd_offset(pud, address);
	370
	371	p4d_k = p4d_offset(pgd_k, address);
	372	pud_k = pud_offset(p4d_k, address);
	373	pmd_k = pmd_offset(pud_k, address);
1da177e4 LT	374
	375	if (pmd_present(pmd) \|\| !pmd_present(pmd_k))
	376	goto bad_area_nosemaphore;
70168dfa	377
1da177e4 LT	378	pmd = pmd_k;
	379	return;
	380	}
	381	}
	382
1da177e4	383	/* This always deals with user addresses. */
50215d65	384	static void force_user_fault(unsigned long address, int write)
1da177e4 LT	385	{
	386	struct vm_area_struct *vma;
	387	struct task_struct *tsk = current;
	388	struct mm_struct *mm = tsk->mm;
759496ba	389	unsigned int flags = FAULT_FLAG_USER;
4b177647	390	int code;
1da177e4	391
4b177647	392	code = SEGV_MAPERR;
1da177e4	393
1da177e4 LT	394	down_read(&mm->mmap_sem);
1da177e4 LT	395	vma = find_vma(mm, address);
70168dfa	396	if (!vma)
1da177e4	397	goto bad_area;
70168dfa	398	if (vma->vm_start <= address)
1da177e4	399	goto good_area;
70168dfa	400	if (!(vma->vm_flags & VM_GROWSDOWN))
1da177e4	401	goto bad_area;
70168dfa	402	if (expand_stack(vma, address))
1da177e4 LT	403	goto bad_area;
1da177e4 LT	404	good_area:
4b177647	405	code = SEGV_ACCERR;
70168dfa SR	406	if (write) {
70168dfa SR	407	if (!(vma->vm_flags & VM_WRITE))
1da177e4	408	goto bad_area;
759496ba	409	flags \|= FAULT_FLAG_WRITE;
1da177e4	410	} else {
70168dfa	411	if (!(vma->vm_flags & (VM_READ \| VM_EXEC)))
1da177e4 LT	412	goto bad_area;
1da177e4 LT	413	}
dcddffd4	414	switch (handle_mm_fault(vma, address, flags)) {
1da177e4 LT	415	case VM_FAULT_SIGBUS:
	416	case VM_FAULT_OOM:
	417	goto do_sigbus;
	418	}
	419	up_read(&mm->mmap_sem);
	420	return;
	421	bad_area:
	422	up_read(&mm->mmap_sem);
4b177647	423	__do_fault_siginfo(code, SIGSEGV, tsk->thread.kregs, address);
1da177e4 LT	424	return;
	425
	426	do_sigbus:
	427	up_read(&mm->mmap_sem);
4b177647	428	__do_fault_siginfo(BUS_ADRERR, SIGBUS, tsk->thread.kregs, address);
1da177e4 LT	429	}
1da177e4 LT	430
9088333e DM	431	static void check_stack_aligned(unsigned long sp)
	432	{
	433	if (sp & 0x7UL)
3cf5d076	434	force_sig(SIGILL);
9088333e DM	435	}
9088333e DM	436
1da177e4 LT	437	void window_overflow_fault(void)
	438	{
	439	unsigned long sp;
	440
	441	sp = current_thread_info()->rwbuf_stkptrs[0];
70168dfa	442	if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
1da177e4 LT	443	force_user_fault(sp + 0x38, 1);
1da177e4 LT	444	force_user_fault(sp, 1);
9088333e DM	445
9088333e DM	446	check_stack_aligned(sp);
1da177e4 LT	447	}
	448
	449	void window_underflow_fault(unsigned long sp)
	450	{
70168dfa	451	if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
1da177e4 LT	452	force_user_fault(sp + 0x38, 0);
1da177e4 LT	453	force_user_fault(sp, 0);
9088333e DM	454
9088333e DM	455	check_stack_aligned(sp);
1da177e4 LT	456	}
	457
	458	void window_ret_fault(struct pt_regs *regs)
	459	{
	460	unsigned long sp;
	461
	462	sp = regs->u_regs[UREG_FP];
70168dfa	463	if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
1da177e4 LT	464	force_user_fault(sp + 0x38, 0);
1da177e4 LT	465	force_user_fault(sp, 0);
9088333e DM	466
9088333e DM	467	check_stack_aligned(sp);
1da177e4	468	}