[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 <linux/extable.h>

#include <asm/page.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);
}

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);
}

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;
	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:
	mmap_read_lock(mm);

	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, regs);

	if (fault_signal_pending(fault, regs))
		return;

	/* The fault is fully completed (including releasing mmap lock) */
	if (fault & VM_FAULT_COMPLETED)
		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 (fault & VM_FAULT_RETRY) {
		flags |= FAULT_FLAG_TRIED;

		/* No need to mmap_read_unlock(mm) as we would
		 * have already released it in __lock_page_or_retry
		 * in mm/filemap.c.
		 */

		goto retry;
	}

	mmap_read_unlock(mm);
	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:
	mmap_read_unlock(mm);

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:
	if (!from_user) {
		const struct exception_table_entry *entry;

		entry = search_exception_tables(regs->pc);
#ifdef DEBUG_EXCEPTIONS
		printk("Exception: PC<%08lx> faddr<%08lx>\n",
		       regs->pc, address);
		printk("EX_TABLE: insn<%08lx> fixup<%08x>\n",
			regs->pc, entry->fixup);
#endif
		regs->pc = entry->fixup;
		regs->npc = regs->pc + 4;
		return;
	}

	unhandled_fault(address, tsk, regs);

/*
 * 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:
	mmap_read_unlock(mm);
	if (from_user) {
		pagefault_out_of_memory();
		return;
	}
	goto no_context;

do_sigbus:
	mmap_read_unlock(mm);
	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;

	mmap_read_lock(mm);
	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, NULL)) {
	case VM_FAULT_SIGBUS:
	case VM_FAULT_OOM:
		goto do_sigbus;
	}
	mmap_read_unlock(mm);
	return;
bad_area:
	mmap_read_unlock(mm);
	__do_fault_siginfo(code, SIGSEGV, tsk->thread.kregs, address);
	return;

do_sigbus:
	mmap_read_unlock(mm);
	__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>
b4edf06c	26	#include <linux/extable.h>
1da177e4	27
1da177e4	28	#include <asm/page.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
4b177647 DM	58	static inline void
	59	show_signal_msg(struct pt_regs *regs, int sig, int code,
	60	unsigned long address, struct task_struct *tsk)
	61	{
	62	if (!unhandled_signal(tsk, sig))
	63	return;
	64
	65	if (!printk_ratelimit())
	66	return;
	67
10a7e9d8	68	printk("%s%s[%d]: segfault at %lx ip %px (rpc %px) sp %px error %x",
4b177647 DM	69	task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG,
	70	tsk->comm, task_pid_nr(tsk), address,
	71	(void )regs->pc, (void )regs->u_regs[UREG_I7],
	72	(void *)regs->u_regs[UREG_FP], code);
	73
	74	print_vma_addr(KERN_CONT " in ", regs->pc);
	75
	76	printk(KERN_CONT "\n");
	77	}
	78
	79	static void __do_fault_siginfo(int code, int sig, struct pt_regs *regs,
	80	unsigned long addr)
	81	{
4b177647	82	if (unlikely(show_unhandled_signals))
d1f5bef6	83	show_signal_msg(regs, sig, code,
4b177647 DM	84	addr, current);
4b177647 DM	85
2c9f7eaf	86	force_sig_fault(sig, code, (void __user *) addr);
4b177647 DM	87	}
4b177647 DM	88
1da177e4 LT	89	static unsigned long compute_si_addr(struct pt_regs *regs, int text_fault)
	90	{
	91	unsigned int insn;
	92
	93	if (text_fault)
	94	return regs->pc;
	95
70168dfa	96	if (regs->psr & PSR_PS)
1da177e4	97	insn = (unsigned int ) regs->pc;
70168dfa	98	else
1da177e4	99	__get_user(insn, (unsigned int *) regs->pc);
1da177e4 LT	100
	101	return safe_compute_effective_address(regs, insn);
	102	}
	103
4b177647 DM	104	static noinline void do_fault_siginfo(int code, int sig, struct pt_regs *regs,
	105	int text_fault)
	106	{
	107	unsigned long addr = compute_si_addr(regs, text_fault);
	108
	109	__do_fault_siginfo(code, sig, regs, addr);
	110	}
	111
1da177e4 LT	112	asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write,
	113	unsigned long address)
	114	{
	115	struct vm_area_struct *vma;
	116	struct task_struct *tsk = current;
	117	struct mm_struct *mm = tsk->mm;
1da177e4	118	int from_user = !(regs->psr & PSR_PS);
50a7ca3c SJ	119	int code;
50a7ca3c SJ	120	vm_fault_t fault;
dde16072	121	unsigned int flags = FAULT_FLAG_DEFAULT;
1da177e4	122
70168dfa	123	if (text_fault)
1da177e4 LT	124	address = regs->pc;
	125
	126	/*
	127	* We fault-in kernel-space virtual memory on-demand. The
	128	* 'reference' page table is init_mm.pgd.
	129	*
	130	* NOTE! We MUST NOT take any locks for this case. We may
	131	* be in an interrupt or a critical region, and should
	132	* only copy the information from the master page table,
	133	* nothing more.
	134	*/
c816be7b	135	code = SEGV_MAPERR;
582a0bae	136	if (address >= TASK_SIZE)
1da177e4 LT	137	goto vmalloc_fault;
1da177e4 LT	138
1da177e4 LT	139	/*
	140	* If we're in an interrupt or have no user
	141	* context, we must not take the fault..
	142	*/
70ffdb93	143	if (pagefault_disabled() \|\| !mm)
70168dfa	144	goto no_context;
1da177e4	145
a8b0ca17	146	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
a084b667	147
c29554f5	148	retry:
d8ed45c5	149	mmap_read_lock(mm);
1da177e4	150
70168dfa	151	if (!from_user && address >= PAGE_OFFSET)
1da177e4 LT	152	goto bad_area;
	153
	154	vma = find_vma(mm, address);
70168dfa	155	if (!vma)
1da177e4	156	goto bad_area;
70168dfa	157	if (vma->vm_start <= address)
1da177e4	158	goto good_area;
70168dfa	159	if (!(vma->vm_flags & VM_GROWSDOWN))
1da177e4	160	goto bad_area;
70168dfa	161	if (expand_stack(vma, address))
1da177e4 LT	162	goto bad_area;
	163	/*
	164	* Ok, we have a good vm_area for this memory access, so
	165	* we can handle it..
	166	*/
	167	good_area:
4b177647	168	code = SEGV_ACCERR;
70168dfa SR	169	if (write) {
70168dfa SR	170	if (!(vma->vm_flags & VM_WRITE))
1da177e4 LT	171	goto bad_area;
	172	} else {
	173	/* Allow reads even for write-only mappings */
70168dfa	174	if (!(vma->vm_flags & (VM_READ \| VM_EXEC)))
1da177e4 LT	175	goto bad_area;
	176	}
	177
759496ba JW	178	if (from_user)
	179	flags \|= FAULT_FLAG_USER;
	180	if (write)
	181	flags \|= FAULT_FLAG_WRITE;
	182
1da177e4 LT	183	/*
	184	* If for any reason at all we couldn't handle the fault,
	185	* make sure we exit gracefully rather than endlessly redo
	186	* the fault.
	187	*/
56e10e6a	188	fault = handle_mm_fault(vma, address, flags, regs);
c29554f5	189
4ef87322	190	if (fault_signal_pending(fault, regs))
c29554f5 KC	191	return;
c29554f5 KC	192
d9272525 PX	193	/* The fault is fully completed (including releasing mmap lock) */
	194	if (fault & VM_FAULT_COMPLETED)
	195	return;
	196
83c54070 NP	197	if (unlikely(fault & VM_FAULT_ERROR)) {
	198	if (fault & VM_FAULT_OOM)
	199	goto out_of_memory;
33692f27 LT	200	else if (fault & VM_FAULT_SIGSEGV)
33692f27 LT	201	goto bad_area;
83c54070 NP	202	else if (fault & VM_FAULT_SIGBUS)
	203	goto do_sigbus;
	204	BUG();
	205	}
c29554f5	206
36ef159f QZ	207	if (fault & VM_FAULT_RETRY) {
36ef159f QZ	208	flags \|= FAULT_FLAG_TRIED;
c29554f5	209
36ef159f QZ	210	/* No need to mmap_read_unlock(mm) as we would
	211	* have already released it in __lock_page_or_retry
	212	* in mm/filemap.c.
	213	*/
c29554f5	214
36ef159f	215	goto retry;
a084b667	216	}
c29554f5	217
d8ed45c5	218	mmap_read_unlock(mm);
1da177e4 LT	219	return;
	220
	221	/*
	222	* Something tried to access memory that isn't in our memory map..
	223	* Fix it, but check if it's kernel or user first..
	224	*/
	225	bad_area:
d8ed45c5	226	mmap_read_unlock(mm);
1da177e4 LT	227
	228	bad_area_nosemaphore:
	229	/* User mode accesses just cause a SIGSEGV */
4b177647 DM	230	if (from_user) {
4b177647 DM	231	do_fault_siginfo(code, SIGSEGV, regs, text_fault);
1da177e4 LT	232	return;
	233	}
	234
	235	/* Is this in ex_table? */
	236	no_context:
0157141a	237	if (!from_user) {
b4edf06c AV	238	const struct exception_table_entry *entry;
	239
	240	entry = search_exception_tables(regs->pc);
1da177e4	241	#ifdef DEBUG_EXCEPTIONS
b4edf06c AV	242	printk("Exception: PC<%08lx> faddr<%08lx>\n",
	243	regs->pc, address);
	244	printk("EX_TABLE: insn<%08lx> fixup<%08x>\n",
	245	regs->pc, entry->fixup);
1da177e4	246	#endif
b4edf06c AV	247	regs->pc = entry->fixup;
	248	regs->npc = regs->pc + 4;
	249	return;
1da177e4	250	}
70168dfa SR	251
70168dfa SR	252	unhandled_fault(address, tsk, regs);
1da177e4 LT	253
	254	/*
	255	* We ran out of memory, or some other thing happened to us that made
	256	* us unable to handle the page fault gracefully.
	257	*/
	258	out_of_memory:
d8ed45c5	259	mmap_read_unlock(mm);
a923c28f DM	260	if (from_user) {
	261	pagefault_out_of_memory();
	262	return;
	263	}
1da177e4 LT	264	goto no_context;
	265
	266	do_sigbus:
d8ed45c5	267	mmap_read_unlock(mm);
4b177647	268	do_fault_siginfo(BUS_ADRERR, SIGBUS, regs, text_fault);
1da177e4 LT	269	if (!from_user)
	270	goto no_context;
	271
	272	vmalloc_fault:
	273	{
	274	/*
	275	* Synchronize this task's top level page-table
	276	* with the 'reference' page table.
	277	*/
	278	int offset = pgd_index(address);
	279	pgd_t pgd, pgd_k;
7235db26 MR	280	p4d_t p4d, p4d_k;
7235db26 MR	281	pud_t pud, pud_k;
1da177e4 LT	282	pmd_t pmd, pmd_k;
	283
	284	pgd = tsk->active_mm->pgd + offset;
	285	pgd_k = init_mm.pgd + offset;
	286
	287	if (!pgd_present(*pgd)) {
	288	if (!pgd_present(*pgd_k))
	289	goto bad_area_nosemaphore;
	290	pgd_val(pgd) = pgd_val(pgd_k);
	291	return;
	292	}
	293
7235db26 MR	294	p4d = p4d_offset(pgd, address);
	295	pud = pud_offset(p4d, address);
	296	pmd = pmd_offset(pud, address);
	297
	298	p4d_k = p4d_offset(pgd_k, address);
	299	pud_k = pud_offset(p4d_k, address);
	300	pmd_k = pmd_offset(pud_k, address);
1da177e4 LT	301
	302	if (pmd_present(pmd) \|\| !pmd_present(pmd_k))
	303	goto bad_area_nosemaphore;
70168dfa	304
1da177e4 LT	305	pmd = pmd_k;
	306	return;
	307	}
	308	}
	309
1da177e4	310	/* This always deals with user addresses. */
50215d65	311	static void force_user_fault(unsigned long address, int write)
1da177e4 LT	312	{
	313	struct vm_area_struct *vma;
	314	struct task_struct *tsk = current;
	315	struct mm_struct *mm = tsk->mm;
759496ba	316	unsigned int flags = FAULT_FLAG_USER;
4b177647	317	int code;
1da177e4	318
4b177647	319	code = SEGV_MAPERR;
1da177e4	320
d8ed45c5	321	mmap_read_lock(mm);
1da177e4	322	vma = find_vma(mm, address);
70168dfa	323	if (!vma)
1da177e4	324	goto bad_area;
70168dfa	325	if (vma->vm_start <= address)
1da177e4	326	goto good_area;
70168dfa	327	if (!(vma->vm_flags & VM_GROWSDOWN))
1da177e4	328	goto bad_area;
70168dfa	329	if (expand_stack(vma, address))
1da177e4 LT	330	goto bad_area;
1da177e4 LT	331	good_area:
4b177647	332	code = SEGV_ACCERR;
70168dfa SR	333	if (write) {
70168dfa SR	334	if (!(vma->vm_flags & VM_WRITE))
1da177e4	335	goto bad_area;
759496ba	336	flags \|= FAULT_FLAG_WRITE;
1da177e4	337	} else {
70168dfa	338	if (!(vma->vm_flags & (VM_READ \| VM_EXEC)))
1da177e4 LT	339	goto bad_area;
1da177e4 LT	340	}
bce617ed	341	switch (handle_mm_fault(vma, address, flags, NULL)) {
1da177e4 LT	342	case VM_FAULT_SIGBUS:
	343	case VM_FAULT_OOM:
	344	goto do_sigbus;
	345	}
d8ed45c5	346	mmap_read_unlock(mm);
1da177e4 LT	347	return;
1da177e4 LT	348	bad_area:
d8ed45c5	349	mmap_read_unlock(mm);
4b177647	350	__do_fault_siginfo(code, SIGSEGV, tsk->thread.kregs, address);
1da177e4 LT	351	return;
	352
	353	do_sigbus:
d8ed45c5	354	mmap_read_unlock(mm);
4b177647	355	__do_fault_siginfo(BUS_ADRERR, SIGBUS, tsk->thread.kregs, address);
1da177e4 LT	356	}
1da177e4 LT	357
9088333e DM	358	static void check_stack_aligned(unsigned long sp)
	359	{
	360	if (sp & 0x7UL)
3cf5d076	361	force_sig(SIGILL);
9088333e DM	362	}
9088333e DM	363
1da177e4 LT	364	void window_overflow_fault(void)
	365	{
	366	unsigned long sp;
	367
	368	sp = current_thread_info()->rwbuf_stkptrs[0];
70168dfa	369	if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
1da177e4 LT	370	force_user_fault(sp + 0x38, 1);
1da177e4 LT	371	force_user_fault(sp, 1);
9088333e DM	372
9088333e DM	373	check_stack_aligned(sp);
1da177e4 LT	374	}
	375
	376	void window_underflow_fault(unsigned long sp)
	377	{
70168dfa	378	if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
1da177e4 LT	379	force_user_fault(sp + 0x38, 0);
1da177e4 LT	380	force_user_fault(sp, 0);
9088333e DM	381
9088333e DM	382	check_stack_aligned(sp);
1da177e4 LT	383	}
	384
	385	void window_ret_fault(struct pt_regs *regs)
	386	{
	387	unsigned long sp;
	388
	389	sp = regs->u_regs[UREG_FP];
70168dfa	390	if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
1da177e4 LT	391	force_user_fault(sp + 0x38, 0);
1da177e4 LT	392	force_user_fault(sp, 0);
9088333e DM	393
9088333e DM	394	check_stack_aligned(sp);
1da177e4	395	}