[net-next-2.6.git] / arch / sparc / mm / fault_32.c

/*
 * 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/interrupt.h>
#include <linux/module.h>
#include <linux/kdebug.h>

#include <asm/system.h>
#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/memreg.h>
#include <asm/openprom.h>
#include <asm/oplib.h>
#include <asm/smp.h>
#include <asm/traps.h>
#include <asm/uaccess.h>

extern int prom_node_root;

/* At boot time we determine these two values necessary for setting
 * up the segment maps and page table entries (pte's).
 */

int num_segmaps, num_contexts;
int invalid_segment;

/* various Virtual Address Cache parameters we find at boot time... */

int vac_size, vac_linesize, vac_do_hw_vac_flushes;
int vac_entries_per_context, vac_entries_per_segment;
int vac_entries_per_page;

/* Return how much physical memory we have.  */
unsigned long probe_memory(void)
{
	unsigned long total = 0;
	int i;

	for (i = 0; sp_banks[i].num_bytes; i++)
		total += sp_banks[i].num_bytes;

	return total;
}

extern void sun4c_complete_all_stores(void);

/* Whee, a level 15 NMI interrupt memory error.  Let's have fun... */
asmlinkage void sparc_lvl15_nmi(struct pt_regs *regs, unsigned long serr,
				unsigned long svaddr, unsigned long aerr,
				unsigned long avaddr)
{
	sun4c_complete_all_stores();
	printk("FAULT: NMI received\n");
	printk("SREGS: Synchronous Error %08lx\n", serr);
	printk("       Synchronous Vaddr %08lx\n", svaddr);
	printk("      Asynchronous Error %08lx\n", aerr);
	printk("      Asynchronous Vaddr %08lx\n", avaddr);
	if (sun4c_memerr_reg)
		printk("     Memory Parity Error %08lx\n", *sun4c_memerr_reg);
	printk("REGISTER DUMP:\n");
	show_regs(regs);
	prom_halt();
}

static void unhandled_fault(unsigned long, struct task_struct *,
		struct pt_regs *) __attribute__ ((noreturn));

static void 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;
}

extern unsigned long safe_compute_effective_address(struct pt_regs *,
						    unsigned int);

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

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;
	siginfo_t info;
	int from_user = !(regs->psr & PSR_PS);
	int fault;

	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.
	 */
	if (!ARCH_SUN4C && address >= TASK_SIZE)
		goto vmalloc_fault;

	info.si_code = SEGV_MAPERR;

	/*
	 * 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);

	/*
	 * The kernel referencing a bad kernel pointer can lock up
	 * a sun4c machine completely, so we must attempt recovery.
	 */
	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:
	info.si_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 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(mm, vma, address, write);
	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)
		current->maj_flt++;
	else
		current->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:
	/* User mode accesses just cause a SIGSEGV */
	if(from_user) {
#if 0
		printk("Fault whee %s [%d]: segfaults at %08lx pc=%08lx\n",
		       tsk->comm, tsk->pid, address, regs->pc);
#endif
		info.si_signo = SIGSEGV;
		info.si_errno = 0;
		/* info.si_code set above to make clear whether
		   this was a SEGV_MAPERR or SEGV_ACCERR fault.  */
		info.si_addr = (void __user *)compute_si_addr(regs, text_fault);
		info.si_trapno = 0;
		force_sig_info (SIGSEGV, &info, tsk);
		return;
	}

	/* Is this in ex_table? */
no_context:
	g2 = regs->u_regs[UREG_G2];
	if (!from_user) {
		fixup = search_extables_range(regs->pc, &g2);
		if (fixup > 10) { /* Values below are reserved for other things */
			extern const unsigned __memset_start[];
			extern const unsigned __memset_end[];
			extern const unsigned __csum_partial_copy_start[];
			extern const unsigned __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);
	printk("VM: killing process %s\n", tsk->comm);
	if (from_user)
		do_group_exit(SIGKILL);
	goto no_context;

do_sigbus:
	up_read(&mm->mmap_sem);
	info.si_signo = SIGBUS;
	info.si_errno = 0;
	info.si_code = BUS_ADRERR;
	info.si_addr = (void __user *) compute_si_addr(regs, text_fault);
	info.si_trapno = 0;
	force_sig_info (SIGBUS, &info, tsk);
	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;
		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;
		}

		pmd = pmd_offset(pgd, address);
		pmd_k = pmd_offset(pgd_k, address);

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

asmlinkage void do_sun4c_fault(struct pt_regs *regs, int text_fault, int write,
			       unsigned long address)
{
	extern void sun4c_update_mmu_cache(struct vm_area_struct *,
					   unsigned long,pte_t);
	extern pte_t *sun4c_pte_offset_kernel(pmd_t *,unsigned long);
	struct task_struct *tsk = current;
	struct mm_struct *mm = tsk->mm;
	pgd_t *pgdp;
	pte_t *ptep;

	if (text_fault) {
		address = regs->pc;
	} else if (!write &&
		   !(regs->psr & PSR_PS)) {
		unsigned int insn, __user *ip;

		ip = (unsigned int __user *)regs->pc;
		if (!get_user(insn, ip)) {
			if ((insn & 0xc1680000) == 0xc0680000)
				write = 1;
		}
	}

	if (!mm) {
		/* We are oopsing. */
		do_sparc_fault(regs, text_fault, write, address);
		BUG();	/* P3 Oops already, you bitch */
	}

	pgdp = pgd_offset(mm, address);
	ptep = sun4c_pte_offset_kernel((pmd_t *) pgdp, address);

	if (pgd_val(*pgdp)) {
	    if (write) {
		if ((pte_val(*ptep) & (_SUN4C_PAGE_WRITE|_SUN4C_PAGE_PRESENT))
				   == (_SUN4C_PAGE_WRITE|_SUN4C_PAGE_PRESENT)) {
			unsigned long flags;

			*ptep = __pte(pte_val(*ptep) | _SUN4C_PAGE_ACCESSED |
				      _SUN4C_PAGE_MODIFIED |
				      _SUN4C_PAGE_VALID |
				      _SUN4C_PAGE_DIRTY);

			local_irq_save(flags);
			if (sun4c_get_segmap(address) != invalid_segment) {
				sun4c_put_pte(address, pte_val(*ptep));
				local_irq_restore(flags);
				return;
			}
			local_irq_restore(flags);
		}
	    } else {
		if ((pte_val(*ptep) & (_SUN4C_PAGE_READ|_SUN4C_PAGE_PRESENT))
				   == (_SUN4C_PAGE_READ|_SUN4C_PAGE_PRESENT)) {
			unsigned long flags;

			*ptep = __pte(pte_val(*ptep) | _SUN4C_PAGE_ACCESSED |
				      _SUN4C_PAGE_VALID);

			local_irq_save(flags);
			if (sun4c_get_segmap(address) != invalid_segment) {
				sun4c_put_pte(address, pte_val(*ptep));
				local_irq_restore(flags);
				return;
			}
			local_irq_restore(flags);
		}
	    }
	}

	/* This conditional is 'interesting'. */
	if (pgd_val(*pgdp) && !(write && !(pte_val(*ptep) & _SUN4C_PAGE_WRITE))
	    && (pte_val(*ptep) & _SUN4C_PAGE_VALID))
		/* Note: It is safe to not grab the MMAP semaphore here because
		 *       we know that update_mmu_cache() will not sleep for
		 *       any reason (at least not in the current implementation)
		 *       and therefore there is no danger of another thread getting
		 *       on the CPU and doing a shrink_mmap() on this vma.
		 */
		sun4c_update_mmu_cache (find_vma(current->mm, address), address,
					*ptep);
	else
		do_sparc_fault(regs, text_fault, write, address);
}

/* 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;
	siginfo_t info;

	info.si_code = SEGV_MAPERR;

#if 0
	printk("wf<pid=%d,wr=%d,addr=%08lx>\n",
	       tsk->pid, write, address);
#endif
	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:
	info.si_code = SEGV_ACCERR;
	if(write) {
		if(!(vma->vm_flags & VM_WRITE))
			goto bad_area;
	} else {
		if(!(vma->vm_flags & (VM_READ | VM_EXEC)))
			goto bad_area;
	}
	switch (handle_mm_fault(mm, vma, address, write)) {
	case VM_FAULT_SIGBUS:
	case VM_FAULT_OOM:
		goto do_sigbus;
	}
	up_read(&mm->mmap_sem);
	return;
bad_area:
	up_read(&mm->mmap_sem);
#if 0
	printk("Window whee %s [%d]: segfaults at %08lx\n",
	       tsk->comm, tsk->pid, address);
#endif
	info.si_signo = SIGSEGV;
	info.si_errno = 0;
	/* info.si_code set above to make clear whether
	   this was a SEGV_MAPERR or SEGV_ACCERR fault.  */
	info.si_addr = (void __user *) address;
	info.si_trapno = 0;
	force_sig_info (SIGSEGV, &info, tsk);
	return;

do_sigbus:
	up_read(&mm->mmap_sem);
	info.si_signo = SIGBUS;
	info.si_errno = 0;
	info.si_code = BUS_ADRERR;
	info.si_addr = (void __user *) address;
	info.si_trapno = 0;
	force_sig_info (SIGBUS, &info, tsk);
}

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

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

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);
}
Commit	Line	Data
88278ca2	1	/*
1da177e4 LT	2	* fault.c: Page fault handlers for the Sparc.
	3	*
	4	* Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
	5	* Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
	6	* Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
	7	*/
	8
	9	#include <asm/head.h>
	10
	11	#include <linux/string.h>
	12	#include <linux/types.h>
	13	#include <linux/sched.h>
	14	#include <linux/ptrace.h>
	15	#include <linux/mman.h>
	16	#include <linux/threads.h>
	17	#include <linux/kernel.h>
	18	#include <linux/signal.h>
	19	#include <linux/mm.h>
	20	#include <linux/smp.h>
1da177e4 LT	21	#include <linux/interrupt.h>
1da177e4 LT	22	#include <linux/module.h>
1eeb66a1	23	#include <linux/kdebug.h>
1da177e4 LT	24
1da177e4 LT	25	#include <asm/system.h>
1da177e4 LT	26	#include <asm/page.h>
	27	#include <asm/pgtable.h>
	28	#include <asm/memreg.h>
	29	#include <asm/openprom.h>
	30	#include <asm/oplib.h>
	31	#include <asm/smp.h>
	32	#include <asm/traps.h>
1da177e4 LT	33	#include <asm/uaccess.h>
1da177e4 LT	34
1da177e4 LT	35	extern int prom_node_root;
	36
	37	/* At boot time we determine these two values necessary for setting
	38	* up the segment maps and page table entries (pte's).
	39	*/
	40
	41	int num_segmaps, num_contexts;
	42	int invalid_segment;
	43
	44	/* various Virtual Address Cache parameters we find at boot time... */
	45
	46	int vac_size, vac_linesize, vac_do_hw_vac_flushes;
	47	int vac_entries_per_context, vac_entries_per_segment;
	48	int vac_entries_per_page;
	49
9f2b2a5f DM	50	/* Return how much physical memory we have. */
9f2b2a5f DM	51	unsigned long probe_memory(void)
1da177e4	52	{
9f2b2a5f DM	53	unsigned long total = 0;
9f2b2a5f DM	54	int i;
1da177e4	55
9f2b2a5f DM	56	for (i = 0; sp_banks[i].num_bytes; i++)
9f2b2a5f DM	57	total += sp_banks[i].num_bytes;
1da177e4	58
1da177e4 LT	59	return total;
	60	}
	61
	62	extern void sun4c_complete_all_stores(void);
	63
	64	/* Whee, a level 15 NMI interrupt memory error. Let's have fun... */
	65	asmlinkage void sparc_lvl15_nmi(struct pt_regs *regs, unsigned long serr,
	66	unsigned long svaddr, unsigned long aerr,
	67	unsigned long avaddr)
	68	{
	69	sun4c_complete_all_stores();
	70	printk("FAULT: NMI received\n");
	71	printk("SREGS: Synchronous Error %08lx\n", serr);
	72	printk(" Synchronous Vaddr %08lx\n", svaddr);
	73	printk(" Asynchronous Error %08lx\n", aerr);
	74	printk(" Asynchronous Vaddr %08lx\n", avaddr);
	75	if (sun4c_memerr_reg)
	76	printk(" Memory Parity Error %08lx\n", *sun4c_memerr_reg);
	77	printk("REGISTER DUMP:\n");
	78	show_regs(regs);
	79	prom_halt();
	80	}
	81
	82	static void unhandled_fault(unsigned long, struct task_struct *,
	83	struct pt_regs *) __attribute__ ((noreturn));
	84
	85	static void unhandled_fault(unsigned long address, struct task_struct *tsk,
	86	struct pt_regs *regs)
	87	{
	88	if((unsigned long) address < PAGE_SIZE) {
	89	printk(KERN_ALERT
	90	"Unable to handle kernel NULL pointer dereference\n");
	91	} else {
	92	printk(KERN_ALERT "Unable to handle kernel paging request "
	93	"at virtual address %08lx\n", address);
	94	}
	95	printk(KERN_ALERT "tsk->{mm,active_mm}->context = %08lx\n",
	96	(tsk->mm ? tsk->mm->context : tsk->active_mm->context));
	97	printk(KERN_ALERT "tsk->{mm,active_mm}->pgd = %08lx\n",
	98	(tsk->mm ? (unsigned long) tsk->mm->pgd :
	99	(unsigned long) tsk->active_mm->pgd));
	100	die_if_kernel("Oops", regs);
	101	}
	102
	103	asmlinkage int lookup_fault(unsigned long pc, unsigned long ret_pc,
	104	unsigned long address)
	105	{
	106	struct pt_regs regs;
	107	unsigned long g2;
	108	unsigned int insn;
	109	int i;
	110
	111	i = search_extables_range(ret_pc, &g2);
	112	switch (i) {
	113	case 3:
	114	/* load & store will be handled by fixup */
	115	return 3;
	116
	117	case 1:
	118	/* store will be handled by fixup, load will bump out */
	119	/* for _to_ macros */
	120	insn = ((unsigned int ) pc);
	121	if ((insn >> 21) & 1)
	122	return 1;
123	break;
124
125	case 2:
126	/* load will be handled by fixup, store will bump out */
127	/* for _from_ macros */
128	insn = ((unsigned int ) pc);
129	if (!((insn >> 21) & 1) \|\| ((insn>>19)&0x3f) == 15)
130	return 2;
131	break;
132
133	default:
134	break;
135	};
136
137	memset(&regs, 0, sizeof (regs));
138	regs.pc = pc;
139	regs.npc = pc + 4;
140	__asm__ __volatile__(
141	"rd %%psr, %0\n\t"
142	"nop\n\t"
143	"nop\n\t"
144	"nop\n" : "=r" (regs.psr));
145	unhandled_fault(address, current, &regs);
146
147	/* Not reached */
148	return 0;
149	}
150
151	extern unsigned long safe_compute_effective_address(struct pt_regs *,
152	unsigned int);
153
154	static unsigned long compute_si_addr(struct pt_regs *regs, int text_fault)
155	{
156	unsigned int insn;
157
158	if (text_fault)
159	return regs->pc;
160
161	if (regs->psr & PSR_PS) {
162	insn = (unsigned int ) regs->pc;
163	} else {
164	__get_user(insn, (unsigned int *) regs->pc);
165	}
166
167	return safe_compute_effective_address(regs, insn);
168	}
169
170	asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write,
171	unsigned long address)
172	{
173	struct vm_area_struct *vma;
174	struct task_struct *tsk = current;
175	struct mm_struct *mm = tsk->mm;
176	unsigned int fixup;
177	unsigned long g2;
178	siginfo_t info;
179	int from_user = !(regs->psr & PSR_PS);
83c54070	180	int fault;
1da177e4 LT	181
	182	if(text_fault)
	183	address = regs->pc;
	184
	185	/*
	186	* We fault-in kernel-space virtual memory on-demand. The
	187	* 'reference' page table is init_mm.pgd.
	188	*
	189	* NOTE! We MUST NOT take any locks for this case. We may
	190	* be in an interrupt or a critical region, and should
	191	* only copy the information from the master page table,
	192	* nothing more.
	193	*/
5110bd21	194	if (!ARCH_SUN4C && address >= TASK_SIZE)
1da177e4 LT	195	goto vmalloc_fault;
	196
	197	info.si_code = SEGV_MAPERR;
	198
	199	/*
	200	* If we're in an interrupt or have no user
	201	* context, we must not take the fault..
	202	*/
	203	if (in_atomic() \|\| !mm)
	204	goto no_context;
	205
	206	down_read(&mm->mmap_sem);
	207
	208	/*
	209	* The kernel referencing a bad kernel pointer can lock up
	210	* a sun4c machine completely, so we must attempt recovery.
	211	*/
	212	if(!from_user && address >= PAGE_OFFSET)
	213	goto bad_area;
	214
	215	vma = find_vma(mm, address);
	216	if(!vma)
	217	goto bad_area;
	218	if(vma->vm_start <= address)
	219	goto good_area;
	220	if(!(vma->vm_flags & VM_GROWSDOWN))
	221	goto bad_area;
	222	if(expand_stack(vma, address))
	223	goto bad_area;
	224	/*
	225	* Ok, we have a good vm_area for this memory access, so
	226	* we can handle it..
	227	*/
	228	good_area:
	229	info.si_code = SEGV_ACCERR;
	230	if(write) {
	231	if(!(vma->vm_flags & VM_WRITE))
	232	goto bad_area;
	233	} else {
	234	/* Allow reads even for write-only mappings */
	235	if(!(vma->vm_flags & (VM_READ \| VM_EXEC)))
	236	goto bad_area;
	237	}
	238
	239	/*
	240	* If for any reason at all we couldn't handle the fault,
	241	* make sure we exit gracefully rather than endlessly redo
	242	* the fault.
	243	*/
83c54070 NP	244	fault = handle_mm_fault(mm, vma, address, write);
	245	if (unlikely(fault & VM_FAULT_ERROR)) {
	246	if (fault & VM_FAULT_OOM)
	247	goto out_of_memory;
	248	else if (fault & VM_FAULT_SIGBUS)
	249	goto do_sigbus;
	250	BUG();
	251	}
	252	if (fault & VM_FAULT_MAJOR)
1da177e4	253	current->maj_flt++;
83c54070	254	else
1da177e4	255	current->min_flt++;
1da177e4 LT	256	up_read(&mm->mmap_sem);
	257	return;
	258
	259	/*
	260	* Something tried to access memory that isn't in our memory map..
	261	* Fix it, but check if it's kernel or user first..
	262	*/
	263	bad_area:
	264	up_read(&mm->mmap_sem);
	265
	266	bad_area_nosemaphore:
	267	/* User mode accesses just cause a SIGSEGV */
	268	if(from_user) {
	269	#if 0
	270	printk("Fault whee %s [%d]: segfaults at %08lx pc=%08lx\n",
	271	tsk->comm, tsk->pid, address, regs->pc);
	272	#endif
	273	info.si_signo = SIGSEGV;
	274	info.si_errno = 0;
	275	/* info.si_code set above to make clear whether
	276	this was a SEGV_MAPERR or SEGV_ACCERR fault. */
	277	info.si_addr = (void __user *)compute_si_addr(regs, text_fault);
	278	info.si_trapno = 0;
	279	force_sig_info (SIGSEGV, &info, tsk);
	280	return;
	281	}
	282
	283	/* Is this in ex_table? */
	284	no_context:
	285	g2 = regs->u_regs[UREG_G2];
0157141a SR	286	if (!from_user) {
0157141a SR	287	fixup = search_extables_range(regs->pc, &g2);
1da177e4 LT	288	if (fixup > 10) { /* Values below are reserved for other things */
	289	extern const unsigned __memset_start[];
	290	extern const unsigned __memset_end[];
	291	extern const unsigned __csum_partial_copy_start[];
	292	extern const unsigned __csum_partial_copy_end[];
	293
	294	#ifdef DEBUG_EXCEPTIONS
	295	printk("Exception: PC<%08lx> faddr<%08lx>\n", regs->pc, address);
	296	printk("EX_TABLE: insn<%08lx> fixup<%08x> g2<%08lx>\n",
	297	regs->pc, fixup, g2);
	298	#endif
	299	if ((regs->pc >= (unsigned long)__memset_start &&
	300	regs->pc < (unsigned long)__memset_end) \|\|
	301	(regs->pc >= (unsigned long)__csum_partial_copy_start &&
	302	regs->pc < (unsigned long)__csum_partial_copy_end)) {
	303	regs->u_regs[UREG_I4] = address;
	304	regs->u_regs[UREG_I5] = regs->pc;
	305	}
	306	regs->u_regs[UREG_G2] = g2;
	307	regs->pc = fixup;
	308	regs->npc = regs->pc + 4;
	309	return;
	310	}
	311	}
	312
	313	unhandled_fault (address, tsk, regs);
	314	do_exit(SIGKILL);
	315
	316	/*
	317	* We ran out of memory, or some other thing happened to us that made
	318	* us unable to handle the page fault gracefully.
	319	*/
	320	out_of_memory:
	321	up_read(&mm->mmap_sem);
	322	printk("VM: killing process %s\n", tsk->comm);
	323	if (from_user)
dcca2bde	324	do_group_exit(SIGKILL);
1da177e4 LT	325	goto no_context;
	326
	327	do_sigbus:
	328	up_read(&mm->mmap_sem);
	329	info.si_signo = SIGBUS;
	330	info.si_errno = 0;
	331	info.si_code = BUS_ADRERR;
	332	info.si_addr = (void __user *) compute_si_addr(regs, text_fault);
	333	info.si_trapno = 0;
	334	force_sig_info (SIGBUS, &info, tsk);
	335	if (!from_user)
	336	goto no_context;
	337
	338	vmalloc_fault:
	339	{
	340	/*
	341	* Synchronize this task's top level page-table
	342	* with the 'reference' page table.
	343	*/
	344	int offset = pgd_index(address);
	345	pgd_t pgd, pgd_k;
	346	pmd_t pmd, pmd_k;
	347
	348	pgd = tsk->active_mm->pgd + offset;
	349	pgd_k = init_mm.pgd + offset;
	350
	351	if (!pgd_present(*pgd)) {
	352	if (!pgd_present(*pgd_k))
	353	goto bad_area_nosemaphore;
	354	pgd_val(pgd) = pgd_val(pgd_k);
	355	return;
	356	}
	357
	358	pmd = pmd_offset(pgd, address);
	359	pmd_k = pmd_offset(pgd_k, address);
	360
	361	if (pmd_present(pmd) \|\| !pmd_present(pmd_k))
	362	goto bad_area_nosemaphore;
	363	pmd = pmd_k;
	364	return;
	365	}
	366	}
	367
	368	asmlinkage void do_sun4c_fault(struct pt_regs *regs, int text_fault, int write,
	369	unsigned long address)
	370	{
	371	extern void sun4c_update_mmu_cache(struct vm_area_struct *,
	372	unsigned long,pte_t);
	373	extern pte_t sun4c_pte_offset_kernel(pmd_t ,unsigned long);
	374	struct task_struct *tsk = current;
	375	struct mm_struct *mm = tsk->mm;
	376	pgd_t *pgdp;
	377	pte_t *ptep;
	378
	379	if (text_fault) {
	380	address = regs->pc;
	381	} else if (!write &&
	382	!(regs->psr & PSR_PS)) {
	383	unsigned int insn, __user *ip;
	384
	385	ip = (unsigned int __user *)regs->pc;
	386	if (!get_user(insn, ip)) {
	387	if ((insn & 0xc1680000) == 0xc0680000)
	388	write = 1;
389	}
390	}
391
392	if (!mm) {
393	/* We are oopsing. */
394	do_sparc_fault(regs, text_fault, write, address);
395	BUG(); /* P3 Oops already, you bitch */
396	}
397
398	pgdp = pgd_offset(mm, address);
399	ptep = sun4c_pte_offset_kernel((pmd_t *) pgdp, address);
400
401	if (pgd_val(*pgdp)) {
402	if (write) {
403	if ((pte_val(*ptep) & (_SUN4C_PAGE_WRITE\|_SUN4C_PAGE_PRESENT))
404	== (_SUN4C_PAGE_WRITE\|_SUN4C_PAGE_PRESENT)) {
405	unsigned long flags;
406
407	ptep = __pte(pte_val(ptep) \| _SUN4C_PAGE_ACCESSED \|
408	_SUN4C_PAGE_MODIFIED \|
409	_SUN4C_PAGE_VALID \|
410	_SUN4C_PAGE_DIRTY);
411
412	local_irq_save(flags);
413	if (sun4c_get_segmap(address) != invalid_segment) {
414	sun4c_put_pte(address, pte_val(*ptep));
415	local_irq_restore(flags);
416	return;
417	}
418	local_irq_restore(flags);
419	}
420	} else {
421	if ((pte_val(*ptep) & (_SUN4C_PAGE_READ\|_SUN4C_PAGE_PRESENT))
422	== (_SUN4C_PAGE_READ\|_SUN4C_PAGE_PRESENT)) {
423	unsigned long flags;
424
425	ptep = __pte(pte_val(ptep) \| _SUN4C_PAGE_ACCESSED \|
426	_SUN4C_PAGE_VALID);
427
428	local_irq_save(flags);
429	if (sun4c_get_segmap(address) != invalid_segment) {
430	sun4c_put_pte(address, pte_val(*ptep));
431	local_irq_restore(flags);
432	return;
433	}
434	local_irq_restore(flags);
435	}
436	}
437	}
438
439	/* This conditional is 'interesting'. */
440	if (pgd_val(pgdp) && !(write && !(pte_val(ptep) & _SUN4C_PAGE_WRITE))
441	&& (pte_val(*ptep) & _SUN4C_PAGE_VALID))
442	/* Note: It is safe to not grab the MMAP semaphore here because
443	* we know that update_mmu_cache() will not sleep for
444	* any reason (at least not in the current implementation)
445	* and therefore there is no danger of another thread getting
446	* on the CPU and doing a shrink_mmap() on this vma.
447	*/
448	sun4c_update_mmu_cache (find_vma(current->mm, address), address,
449	*ptep);
450	else
451	do_sparc_fault(regs, text_fault, write, address);
452	}
453
454	/* This always deals with user addresses. */
50215d65	455	static void force_user_fault(unsigned long address, int write)
1da177e4 LT	456	{
	457	struct vm_area_struct *vma;
	458	struct task_struct *tsk = current;
	459	struct mm_struct *mm = tsk->mm;
	460	siginfo_t info;
	461
	462	info.si_code = SEGV_MAPERR;
	463
	464	#if 0
	465	printk("wf<pid=%d,wr=%d,addr=%08lx>\n",
	466	tsk->pid, write, address);
	467	#endif
	468	down_read(&mm->mmap_sem);
	469	vma = find_vma(mm, address);
	470	if(!vma)
	471	goto bad_area;
	472	if(vma->vm_start <= address)
	473	goto good_area;
	474	if(!(vma->vm_flags & VM_GROWSDOWN))
	475	goto bad_area;
	476	if(expand_stack(vma, address))
	477	goto bad_area;
	478	good_area:
	479	info.si_code = SEGV_ACCERR;
	480	if(write) {
	481	if(!(vma->vm_flags & VM_WRITE))
	482	goto bad_area;
	483	} else {
	484	if(!(vma->vm_flags & (VM_READ \| VM_EXEC)))
	485	goto bad_area;
	486	}
	487	switch (handle_mm_fault(mm, vma, address, write)) {
	488	case VM_FAULT_SIGBUS:
	489	case VM_FAULT_OOM:
	490	goto do_sigbus;
	491	}
	492	up_read(&mm->mmap_sem);
	493	return;
	494	bad_area:
	495	up_read(&mm->mmap_sem);
	496	#if 0
	497	printk("Window whee %s [%d]: segfaults at %08lx\n",
	498	tsk->comm, tsk->pid, address);
	499	#endif
	500	info.si_signo = SIGSEGV;
	501	info.si_errno = 0;
	502	/* info.si_code set above to make clear whether
	503	this was a SEGV_MAPERR or SEGV_ACCERR fault. */
	504	info.si_addr = (void __user *) address;
	505	info.si_trapno = 0;
	506	force_sig_info (SIGSEGV, &info, tsk);
	507	return;
	508
	509	do_sigbus:
	510	up_read(&mm->mmap_sem);
	511	info.si_signo = SIGBUS;
	512	info.si_errno = 0;
	513	info.si_code = BUS_ADRERR;
	514	info.si_addr = (void __user *) address;
	515	info.si_trapno = 0;
	516	force_sig_info (SIGBUS, &info, tsk);
	517	}
	518
	519	void window_overflow_fault(void)
520	{
521	unsigned long sp;
522
523	sp = current_thread_info()->rwbuf_stkptrs[0];
524	if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
525	force_user_fault(sp + 0x38, 1);
526	force_user_fault(sp, 1);
527	}
528
529	void window_underflow_fault(unsigned long sp)
530	{
531	if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
532	force_user_fault(sp + 0x38, 0);
533	force_user_fault(sp, 0);
534	}
535
536	void window_ret_fault(struct pt_regs *regs)
537	{
538	unsigned long sp;
539
540	sp = regs->u_regs[UREG_FP];
541	if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
542	force_user_fault(sp + 0x38, 0);
543	force_user_fault(sp, 0);
544	}