1/*
  2 *  Meta page fault handling.
  3 *
  4 *  Copyright (C) 2005-2012 Imagination Technologies Ltd.
  5 */
  6
  7#include <linux/mman.h>
  8#include <linux/mm.h>
  9#include <linux/kernel.h>
 10#include <linux/ptrace.h>
 11#include <linux/interrupt.h>
 12#include <linux/uaccess.h>
 13
 14#include <asm/tlbflush.h>
 15#include <asm/mmu.h>
 16#include <asm/traps.h>
 17
 18/* Clear any pending catch buffer state. */
 19static void clear_cbuf_entry(struct pt_regs *regs, unsigned long addr,
 20			     unsigned int trapno)
 21{
 22	PTBICTXEXTCB0 cbuf = regs->extcb0;
 23
 24	switch (trapno) {
 25		/* Instruction fetch faults leave no catch buffer state. */
 26	case TBIXXF_SIGNUM_IGF:
 27	case TBIXXF_SIGNUM_IPF:
 28		return;
 29	default:
 30		if (cbuf[0].CBAddr == addr) {
 31			cbuf[0].CBAddr = 0;
 32			cbuf[0].CBFlags &= ~TXCATCH0_FAULT_BITS;
 33
 34			/* And, as this is the ONLY catch entry, we
 35			 * need to clear the cbuf bit from the context!
 36			 */
 37			regs->ctx.SaveMask &= ~(TBICTX_CBUF_BIT |
 38						TBICTX_XCBF_BIT);
 39
 40			return;
 41		}
 42		pr_err("Failed to clear cbuf entry!\n");
 43	}
 44}
 45
 46int show_unhandled_signals = 1;
 47
 48int do_page_fault(struct pt_regs *regs, unsigned long address,
 49		  unsigned int write_access, unsigned int trapno)
 50{
 51	struct task_struct *tsk;
 52	struct mm_struct *mm;
 53	struct vm_area_struct *vma, *prev_vma;
 54	siginfo_t info;
 55	int fault;
 56	unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
 57
 58	tsk = current;
 59
 60	if ((address >= VMALLOC_START) && (address < VMALLOC_END)) {
 61		/*
 62		 * Synchronize this task's top level page-table
 63		 * with the 'reference' page table.
 64		 *
 65		 * Do _not_ use "tsk" here. We might be inside
 66		 * an interrupt in the middle of a task switch..
 67		 */
 68		int offset = pgd_index(address);
 69		pgd_t *pgd, *pgd_k;
 70		pud_t *pud, *pud_k;
 71		pmd_t *pmd, *pmd_k;
 72		pte_t *pte_k;
 73
 74		pgd = ((pgd_t *)mmu_get_base()) + offset;
 75		pgd_k = swapper_pg_dir + offset;
 76
 77		/* This will never happen with the folded page table. */
 78		if (!pgd_present(*pgd)) {
 79			if (!pgd_present(*pgd_k))
 80				goto bad_area_nosemaphore;
 81			set_pgd(pgd, *pgd_k);
 82			return 0;
 83		}
 84
 85		pud = pud_offset(pgd, address);
 86		pud_k = pud_offset(pgd_k, address);
 87		if (!pud_present(*pud_k))
 88			goto bad_area_nosemaphore;
 89		set_pud(pud, *pud_k);
 90
 91		pmd = pmd_offset(pud, address);
 92		pmd_k = pmd_offset(pud_k, address);
 93		if (!pmd_present(*pmd_k))
 94			goto bad_area_nosemaphore;
 95		set_pmd(pmd, *pmd_k);
 96
 97		pte_k = pte_offset_kernel(pmd_k, address);
 98		if (!pte_present(*pte_k))
 99			goto bad_area_nosemaphore;
100
101		/* May only be needed on Chorus2 */
102		flush_tlb_all();
103		return 0;
104	}
105
106	mm = tsk->mm;
107
108	if (faulthandler_disabled() || !mm)
109		goto no_context;
110
111	if (user_mode(regs))
112		flags |= FAULT_FLAG_USER;
113retry:
114	down_read(&mm->mmap_sem);
115
116	vma = find_vma_prev(mm, address, &prev_vma);
117
118	if (!vma || address < vma->vm_start)
119		goto check_expansion;
120
121good_area:
122	if (write_access) {
123		if (!(vma->vm_flags & VM_WRITE))
124			goto bad_area;
125		flags |= FAULT_FLAG_WRITE;
126	} else {
127		if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
128			goto bad_area;
129	}
130
131	/*
132	 * If for any reason at all we couldn't handle the fault,
133	 * make sure we exit gracefully rather than endlessly redo
134	 * the fault.
135	 */
136	fault = handle_mm_fault(mm, vma, address, flags);
137
138	if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
139		return 0;
140
141	if (unlikely(fault & VM_FAULT_ERROR)) {
142		if (fault & VM_FAULT_OOM)
143			goto out_of_memory;
144		else if (fault & VM_FAULT_SIGSEGV)
145			goto bad_area;
146		else if (fault & VM_FAULT_SIGBUS)
147			goto do_sigbus;
148		BUG();
149	}
150	if (flags & FAULT_FLAG_ALLOW_RETRY) {
151		if (fault & VM_FAULT_MAJOR)
152			tsk->maj_flt++;
153		else
154			tsk->min_flt++;
155		if (fault & VM_FAULT_RETRY) {
156			flags &= ~FAULT_FLAG_ALLOW_RETRY;
157			flags |= FAULT_FLAG_TRIED;
158
159			/*
160			 * No need to up_read(&mm->mmap_sem) as we would
161			 * have already released it in __lock_page_or_retry
162			 * in mm/filemap.c.
163			 */
164
165			goto retry;
166		}
167	}
168
169	up_read(&mm->mmap_sem);
170	return 0;
171
172check_expansion:
173	vma = prev_vma;
174	if (vma && (expand_stack(vma, address) == 0))
175		goto good_area;
176
177bad_area:
178	up_read(&mm->mmap_sem);
179
180bad_area_nosemaphore:
181	if (user_mode(regs)) {
182		info.si_signo = SIGSEGV;
183		info.si_errno = 0;
184		info.si_code = SEGV_MAPERR;
185		info.si_addr = (__force void __user *)address;
186		info.si_trapno = trapno;
187
188		if (show_unhandled_signals && unhandled_signal(tsk, SIGSEGV) &&
189		    printk_ratelimit()) {
190			pr_info("%s%s[%d]: segfault at %lx pc %08x sp %08x write %d trap %#x (%s)",
191			       task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG,
192			       tsk->comm, task_pid_nr(tsk), address,
193			       regs->ctx.CurrPC, regs->ctx.AX[0].U0,
194			       write_access, trapno, trap_name(trapno));
195			print_vma_addr(" in ", regs->ctx.CurrPC);
196			print_vma_addr(" rtp in ", regs->ctx.DX[4].U1);
197			printk("\n");
198			show_regs(regs);
199		}
200		force_sig_info(SIGSEGV, &info, tsk);
201		return 1;
202	}
203	goto no_context;
204
205do_sigbus:
206	up_read(&mm->mmap_sem);
207
208	/*
209	 * Send a sigbus, regardless of whether we were in kernel
210	 * or user mode.
211	 */
212	info.si_signo = SIGBUS;
213	info.si_errno = 0;
214	info.si_code = BUS_ADRERR;
215	info.si_addr = (__force void __user *)address;
216	info.si_trapno = trapno;
217	force_sig_info(SIGBUS, &info, tsk);
218
219	/* Kernel mode? Handle exceptions or die */
220	if (!user_mode(regs))
221		goto no_context;
222
223	return 1;
224
225	/*
226	 * We ran out of memory, or some other thing happened to us that made
227	 * us unable to handle the page fault gracefully.
228	 */
229out_of_memory:
230	up_read(&mm->mmap_sem);
231	if (user_mode(regs)) {
232		pagefault_out_of_memory();
233		return 1;
234	}
235
236no_context:
237	/* Are we prepared to handle this kernel fault?  */
238	if (fixup_exception(regs)) {
239		clear_cbuf_entry(regs, address, trapno);
240		return 1;
241	}
242
243	die("Oops", regs, (write_access << 15) | trapno, address);
244	do_exit(SIGKILL);
245}